create-byan-agent 2.50.0 → 2.53.0

package/CHANGELOG.md

@@ -9,6 +9,99 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.53.0] - 2026-07-21
+
+### Added — Rail automatique : workflow natif byan-auto-dispatch (F2)
+- Nouveau workflow Claude natif `.claude/workflows/byan-auto-dispatch.js` : il
+  decoupe une tache en etapes typees (nature + complexite 0-100) via un agent
+  d'analyse (sonnet, schema JSON force), route chaque etape sur le bon modele
+  par l'echelle v3 (haiku < 34, sonnet < 67, opus < 90, fable >= 90), route les
+  etapes shell/deploiement/navigation vers Codex (repli Claude annonce si Codex
+  n'est pas disponible ; la verification reste sur le modele de session, non
+  deleguee), ecrit `_byan-output/plan.md` (table etape x nature x complexite x
+  moteur x modele + consignes), execute chaque etape en sequence sur le modele
+  route, et verifie le livrable en fin.
+- Cablage skill `byan-byan` (section 0.5) : a CHAQUE tache non-conversationnelle
+  recue par `/byan-byan`, ce workflow est invoque AUTOMATIQUEMENT (scriptPath +
+  args {task, stamp}), sans demande a l'utilisateur. Exceptions nommees :
+  question simple, action destructive (confirmation d'abord), FD multi-feature
+  deja engage (sa phase DISPATCH peut invoquer le meme workflow par feature),
+  demande explicite d'execution directe. Le gate utilisateur reste en fin, sur
+  le livrable.
+- Livraison npm : le script est ajoute au miroir `template-sync.js`.
+
+### Changed — Langage precis, zero dialecte interne (F1, Mantra IA-26)
+- Le filet plain-language s'etend : `nudge`, `up-tier`, `ladder`, `rung`,
+  `runtime` rejoignent les mots a remplacer en prose ; nouvelle detection de
+  l'anthropomorphisme d'outil (un MCP/serveur/hook dit "vivant" ou "mort") avec
+  le remplacement exige : le fait observe, outil nomme ("byan_ping a repondu en
+  0.3s", "le serveur ne repond pas, timeout 8s").
+- Nouvelle clause de precision factuelle dans `.claude/rules/plain-language.md` :
+  tout etat d'outil = l'outil nomme + l'appel + le resultat exact ; pas de
+  resume flou ("ca marche") ; "non verifie" quand l'appel n'a pas ete fait.
+- L'ancre de voix par tour et le tao (Section 4, Vocabulaire Interdit) portent
+  les deux nouveaux interdits. Tests jest etendus (26 verts sur la suite
+  plain-language).
+
+## [2.52.0] - 2026-07-20
+
+### Changed — Delegation Codex v3 : pression-only + obeissance au routeur (F1, F2)
+- **F1 — la delegation ne se declenche plus que sous PRESSION budget.** La nature
+  d'une tache (code / mecanique) n'est plus un declencheur d'auto-delegation a elle
+  seule. Deleguer au Codex de l'abonnement (qui reste en dessous de Claude en
+  qualite) vaut le coup pour epargner le budget Claude, pas par tache de code. Hors
+  pression, le code tourne sur Claude sans rappel. Le seuil par defaut passe a 75 %
+  (`autodelegate-decision.js` + `codex-delegate-guard.js` alignes sur un seul
+  nombre). Sans jauge `budget`, la pression n'est pas calculee et rien n'est
+  propose (documente, non bloquant).
+- **F2 — le garde `codex-delegate-guard` obeit au routeur.** Le blocage ne mord
+  que pour une tache que le `dispatch-router` route lui-meme vers Codex (nature
+  execution / shell / deploiement / devops / navigateur). Une tache
+  architecture / refactor / qualite / planif — et toute verification — route vers
+  Claude, donc le garde reste silencieux. Le garde recalcule router + pression
+  uniquement dans la branche ou un blocage est encore possible (les chemins
+  d'autorisation courants ne paient rien) ; les deux signaux echouent en mode
+  ouvert (signal irresolu -> on autorise, sans blocage a tort).
+
+### Changed — Echelle de modele par complexite + Fable dernier recours (F3)
+- **Cote routeur (`dispatch-router.claudeModelForComplexity`)** : echelle a quatre
+  rungs — `haiku` (bas) -> `sonnet` (moyen) -> `opus` (haut) -> `fable` (extreme,
+  dernier recours, ~2x le prix d'Opus). C'est une RECOMMANDATION par tache, pas un
+  changement du modele de session en cours (Claude Code n'expose pas ce levier).
+- **Cote leaves de workflow (`native-tiers` + linter)** : un up-tier explicite
+  (`opus` / `fable`) devient un choix d'auteur AUTORISE sur n'importe quel leaf,
+  miroir de l'echelle du routeur. Le plancher anti-downgrade est conserve (haiku /
+  sonnet interdits sur un leaf protege) ; seul le plafond est ouvert (le pin-up
+  n'est plus une violation). Nouveaux : `UP_TIER_MODELS`, `isUpTierModel`.
+- **Revirement d'invariant assume** : l'ancienne ligne rouge "pas de Fable /
+  pas de pin-up" est levee cote Claude. Cote Codex elle tient (Codex ne peut pas
+  lancer un modele Claude) : `assertNoFable` garde le chemin Codex + `codex-bridge`.
+- Doctrine alignee : `native-workflows.md`, `native-workflows-contract.md`,
+  `intelligent-dispatch.md`, `codex-auto-delegation.md`, skill `byan-byan`.
+
+## [2.51.0] - 2026-07-20
+
+### Changed — Delegation Codex : fermeture de l'auto-esquive (option B)
+- Le blocage `codex-delegate-guard` ne peut plus etre contourne par BYAN lui-meme.
+  Retire : la marque de contenu auto-ecrite (`// BYAN-DELEGATE: reviewed`) et
+  l'auto-passe par re-soumission/fenetre de grace — les deux permettaient a Claude
+  de s'auto-accorder la sortie. Les seules sorties valides sont desormais : une
+  delegation Codex reelle ce tour, Codex indisponible (detecte via `codex --version`),
+  ou un opt-out HUMAIN ("reste sur claude" / "sans codex" dans la demande, ou le
+  fichier `.byan-codex-autodelegate/off`). Le motif "script court / latence / je
+  verifie" n'est plus une raison valide. Coeur pur `lib/codex-delegate-gate.js`
+  (`humanOptOutFromText`, `decideDelegateGate` durci) + `codex-delegate-guard.js`
+  (probe Codex, opt-out depuis la demande). Le rendu injecte (`autodelegate-decision`
+  renderNudge), le skill `byan-byan` et `docs/codex-auto-delegation.md` sont alignes.
+
+### Notes
+- Constat de session : le CLI Codex de l'abo ChatGPT est plafonne a gpt-5.5 (5.6
+  refuse). Recherche croisee : gpt-5.5 est sous le meilleur Claude sur tous les
+  domaines mesures. Donc la delegation Codex vaut pour economiser le budget Claude,
+  pas pour la qualite. Prochain chantier (FD dedie) : delegation declenchee par la
+  PRESSION budget (~75%) au lieu de par-nature ; le blocage obeit au routeur ;
+  echelle modele Claude par complexite (haiku/sonnet/opus) + Fable en dernier recours.
+
 ## [2.50.0] - 2026-07-17
 
 ### Added — BYAN souverainete (les concepts BYAN pilotent Claude, ne se font plus doubler)

package/install/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.50.0",
+  "version": "2.51.0",
   "description": "BYAN - Intelligent AI agent installer with multi-platform native support (Claude Code, Codex/OpenCode)",
   "bin": {
     "create-byan-agent": "bin/create-byan-agent-v2.js"

package/install/templates/.claude/hooks/codex-delegate-guard.js

@@ -1,35 +1,31 @@
 #!/usr/bin/env node
 'use strict';
 
-// PreToolUse hook — WI-1, the DENT for the armed Codex-delegation lane.
+// PreToolUse hook — the armed Codex-delegation guard (v3 : router-obedient +
+// pressure-gated). See lib/codex-delegate-gate.js for the policy.
 //
-// When the Codex lane is ARMED (yanstaller option on AND Codex linked) and the
-// current turn is about to WRITE delegable code without having delegated to Codex
-// first, DENY ONCE with the exact instruction to delegate. This is the tooth that
-// makes "delegate to Codex when armed" govern instead of being prose Claude can
-// double with a polite excuse (the session incident).
+// It DENIES a code Write/Edit only when ALL hold : the lane is armed (yanstaller
+// option on AND Codex linked), the ROUTER routes the task to Codex, we are under
+// Claude budget PRESSURE, Codex is available, and no delegation happened this turn
+// — and the human has not opted out. Otherwise it allows. Never traps a turn on an
+// internal error (fails open), always exits 0.
 //
-// Speed-bump, not a wall (the user's red line) :
-//   - escape-hatch : `.byan-codex-autodelegate/off` silences it (shared with the
-//     nudge hook — one switch for the whole Codex-delegation posture).
-//   - `// BYAN-DELEGATE: reviewed` in the file acknowledges a deliberate
-//     Claude-lane choice (Codex unavailable, judgment/verify) and passes.
-//   - deny-once : an identical resubmission passes, and a grace window after a
-//     deny lets a multi-file build proceed without nagging on every file.
-//
-// Never traps a turn, always exits 0. Pure decision in lib/codex-delegate-gate.js;
-// armed/linked detection reused from codex-autodelegate.js; delegability from
-// autodelegate-decision.js; the turn transcript via transcript-read.js.
+// The two computed signals (router decision, budget pressure) are only evaluated
+// in the would-deny branch, so the common allow paths pay nothing. Both fail open
+// (an unresolvable signal -> allow, never a wrong block).
 
 const fs = require('fs');
 const path = require('path');
+const { spawnSync } = require('child_process');
+const { pathToFileURL } = require('url');
 const gate = require('./lib/codex-delegate-gate');
 const { loadConfig, codexLinked, toggledOff } = require('./codex-autodelegate');
-const { looksDelegable } = require('./lib/autodelegate-decision');
-const { extractRecentMessages, extractLastAssistantText, contentToText } = require('./lib/transcript-read');
+const { estimateClaudeUsage } = require('./lib/usage-estimator');
+const { extractRecentMessages, contentToText } = require('./lib/transcript-read');
 
 const ROOT = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-const GRACE_MS = 120000;
+const ROUTER_PATH = path.resolve(__dirname, '../../_byan/mcp/byan-mcp-server/lib/dispatch-router.js');
+const DEFAULT_PRESSURE_THRESHOLD = 75; // % of the Claude budget window
 
 function readStdin() {
   return new Promise((resolve) => {
@@ -40,44 +36,47 @@ function readStdin() {
   });
 }
 
-function allow() {
-  return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow' } };
-}
-
-function deny(reason) {
-  return {
-    hookSpecificOutput: {
-      hookEventName: 'PreToolUse',
-      permissionDecision: 'deny',
-      permissionDecisionReason: reason,
-    },
-  };
-}
+const allow = () => ({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow' } });
+const deny = (reason) => ({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: reason } });
 
-function sidecarPath(root) {
-  return path.join(root, '.byan-codex-delegate', 'last-deny.json');
+// Codex availability probe : `codex --version` exits 0. Absent/broken -> false ->
+// the guard must NOT deny (staying on Claude is the legit fallback).
+function probeCodexAvailable(runner = spawnSync) {
+  try {
+    const res = runner('codex', ['--version'], { timeout: 8000, encoding: 'utf8' });
+    return res && res.status === 0;
+  } catch (_e) {
+    return false;
+  }
 }
 
-function readPriorDeny(root) {
+// routerSaysCodex(text) : does dispatch-router route this task's text to Codex?
+// The router keyword-matches on the text (execution/shell/deploy/script...). ESM
+// module dynamically imported from this CJS hook. Fails open (false = don't block)
+// if the router cannot be loaded.
+async function defaultRouteProbe(text) {
   try {
-    const p = JSON.parse(fs.readFileSync(sidecarPath(root), 'utf8'));
-    return p && typeof p === 'object' ? p : null;
+    const mod = await import(pathToFileURL(ROUTER_PATH).href);
+    return mod.routeRuntime(String(text || '')) === 'codex';
   } catch (_e) {
-    return null;
+    return false;
   }
 }
 
-function writePriorDeny(root, entry) {
+// underPressure : Claude budget usage >= threshold. Needs a budget in the config
+// (no budget -> pct null -> not under pressure -> no delegation, documented).
+function computeUnderPressure(config) {
   try {
-    fs.mkdirSync(path.dirname(sidecarPath(root)), { recursive: true });
-    fs.writeFileSync(sidecarPath(root), JSON.stringify(entry));
+    const budget = config && config.budget ? config.budget : null;
+    if (!budget) return false;
+    const threshold = typeof config.threshold === 'number' ? config.threshold : DEFAULT_PRESSURE_THRESHOLD;
+    const usage = estimateClaudeUsage({ budget });
+    return typeof usage.pct === 'number' && usage.pct >= threshold;
   } catch (_e) {
-    // best-effort : losing the deny memory only costs one extra deny, never a trap
+    return false;
   }
 }
 
-// The last user message text this turn, for the delegability signal (a code
-// target already suffices, this only broadens it).
 function lastUserText(payload) {
   const msgs = extractRecentMessages(payload, 12);
   if (!Array.isArray(msgs)) return '';
@@ -87,45 +86,38 @@ function lastUserText(payload) {
   return '';
 }
 
-// Pure-ish assembly of the decision from a payload (exported for tests, fs
-// injected via opts.root + opts.now).
-function runGuard(payload, { root = ROOT, now = Date.now() } = {}) {
+// runGuard — async (the router import is async). opts inject the probes for tests.
+async function runGuard(payload, {
+  root = ROOT,
+  codexProbe = probeCodexAvailable,
+  routeProbe = defaultRouteProbe,
+  pressureProbe = computeUnderPressure,
+} = {}) {
   const toolName = payload.tool_name || payload.toolName || '';
   if (toolName !== 'Write' && toolName !== 'Edit') return allow();
 
   const config = loadConfig(root);
   const armed = config.enabled === true && codexLinked();
-  const escaped = toggledOff(root);
+  if (!armed) return allow(); // fast path, no transcript/probe work when off
 
+  const escaped = toggledOff(root);
   const input = payload.tool_input || payload.toolInput || {};
   const filePath = input.file_path || input.filePath || '';
-  const content = toolName === 'Edit'
-    ? String(input.new_string || input.newString || '')
-    : String(input.content || '');
-
-  const userText = lastUserText(payload);
-  const delegable = gate.targetIsCode(filePath) || looksDelegable(userText);
-  const reviewedMarker = gate.hasReviewedMarker(content) || gate.hasReviewedMarker(extractLastAssistantText(payload));
+  const isCode = gate.targetIsCode(filePath);
+  const humanOptOut = gate.humanOptOutFromText(lastUserText(payload));
   const delegationSeen = gate.delegationSeenThisTurn(extractRecentMessages(payload, 12) || []);
-  const turnHash = gate.hashTurn(filePath, content);
+
+  // Only compute the two expensive signals when a deny is otherwise possible.
+  const maybeDeny = !escaped && !humanOptOut && isCode && !delegationSeen;
+  const routerSaysCodex = maybeDeny ? await routeProbe(lastUserText(payload)) : false;
+  const underPressure = (maybeDeny && routerSaysCodex) ? pressureProbe(config) : false;
+  const codexAvailable = (maybeDeny && routerSaysCodex && underPressure) ? codexProbe() : true;
 
   const decision = gate.decideDelegateGate({
-    armed,
-    delegable,
-    delegationSeen,
-    escaped,
-    reviewedMarker,
-    priorDeny: readPriorDeny(root),
-    turnHash,
-    now,
-    graceMs: GRACE_MS,
+    armed, routerSaysCodex, targetIsCode: isCode, underPressure,
+    delegationSeen, escaped, humanOptOut, codexAvailable,
   });
-
-  if (decision.decision === 'deny') {
-    writePriorDeny(root, { hash: turnHash, ts: now });
-    return deny(decision.reason);
-  }
-  return allow();
+  return decision.decision === 'deny' ? deny(decision.reason) : allow();
 }
 
 if (require.main === module) {
@@ -133,7 +125,7 @@ if (require.main === module) {
     let out;
     try {
       const payload = JSON.parse((await readStdin()) || '{}');
-      out = runGuard(payload);
+      out = await runGuard(payload);
     } catch (_e) {
       out = allow();
     }
@@ -142,4 +134,4 @@ if (require.main === module) {
   })();
 }
 
-module.exports = { runGuard, sidecarPath, readPriorDeny, writePriorDeny, lastUserText };
+module.exports = { runGuard, probeCodexAvailable, defaultRouteProbe, computeUnderPressure, lastUserText };

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

@@ -36,7 +36,8 @@ const ANCHOR = [
   '- 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, pas de métaphore collée de travers ("forger" un token).',
+  '- 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;

package/install/templates/.claude/hooks/lib/autodelegate-decision.js

@@ -22,7 +22,7 @@
 
 const { perfFavors } = require('./perf-routing');
 
-const DEFAULT_THRESHOLD = 80;
+const DEFAULT_THRESHOLD = 75;
 const DEFAULT_INVOCATION = 'codex:codex-rescue --model gpt-5.4';
 const RED_LINE = 'delegable work only (code / mechanical) — judgment, analysis, soul and verification stay on Claude';
 
@@ -71,16 +71,12 @@ function decideAutodelegation({ requestText = '', usage = null, config = {} } =
     };
   }
 
-  if (delegable) {
-    return {
-      delegate: true,
-      mode: 'delegable-only',
-      pct,
-      reason: 'request looks like delegable coding work — propose handing it to Codex to spare the Claude 5h budget',
-      redLine: RED_LINE,
-      invocation,
-    };
-  }
+  // v3 : NATURE alone is no longer an auto-delegate trigger. The user's decision
+  // is PRESSURE-only — delegating to the subscription Codex (which trails Claude
+  // on quality) is worth it to spare the Claude budget, not per coding task. So a
+  // delegable task off-pressure does NOT propose Codex. `delegable` is kept only as
+  // a signal the perf-routing opt-in below can still use.
+  void delegable;
 
   // PERF (opt-in): the forces table (user-populated) may favor Codex for this
   // kind of task even at low pressure. Off by default; always heuristic.
@@ -141,8 +137,10 @@ function renderNudge(decision) {
     `[BYAN auto-delegate]${gauge}: ${scope} via \`${invocation}\` `
       + '(runs on the ChatGPT subscription, no API credit).',
     `Red line: ${decision.redLine}. The lane is ARMED (option on AND Codex linked), so this is a `
-      + 'DIRECTIVE, not a mere suggestion: delegate the delegable part unless you have a specific reason '
-      + "not to, fall back to Claude only if Codex is unavailable, and verify Codex's output before commit.",
+      + 'DIRECTIVE, not a suggestion: delegate the delegable part. The ONLY valid reasons to stay on '
+      + 'Claude are (1) Codex unavailable, or (2) the user asked to stay on Claude. "Small script / '
+      + 'latency / I verify anyway" is NOT a valid reason — the codex-delegate-guard denies a delegable '
+      + "code write that skips Codex. Verify Codex's output before commit.",
   ].join(' ');
 }
 

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

@@ -32,6 +32,11 @@ const OFFENDERS = Object.freeze([
   { term: 'gate', good: 'point de controle / porte' },
   { term: 'leaf', good: 'etape / tache' },
   { term: 'tier', good: 'niveau / gamme' },
+  { term: 'nudge', good: 'rappel / conseil injecte' },
+  { term: 'up-tier', good: 'monter en gamme' },
+  { term: 'ladder', good: 'echelle' },
+  { term: 'rung', good: 'palier' },
+  { term: 'runtime', good: "moteur d'execution" },
 ]);
 
 // A metaphor misuse, not a single word: "forger" applied to a token/jeton.
@@ -43,6 +48,19 @@ const METAPHOR_OFFENDERS = Object.freeze([
     label: 'forger un token',
     good: 'generer / creer un token',
   },
+  {
+    // Anthropomorphism applied to a tool: an MCP/serveur/hook is not "vivant" or
+    // "mort" — the precise statement is the observed fact ("byan_ping a repondu",
+    // "le serveur ne repond pas, timeout 8s"). The predicate must be COPULA-bound
+    // to the tool word ("le serveur est mort", "l'API semble morte") : bare
+    // proximity would misfire on fixed French idioms near a tool word ("point
+    // mort", "angle mort", "temps mort", "nature morte", "communaute vivante"),
+    // which carry no anthropomorphism at all.
+    id: 'outil-vivant-mort',
+    re: /\b(?:mcp|serveur|outil|hook|api|tool)s?\b[^.!?\n]{0,40}\b(?:est|sont|etait|était|etaient|étaient|semble|semblent|parait|paraît|paraissent|reste|restent)\s+(?:bien\s+|encore\s+|toujours\s+|deja\s+|déjà\s+)?(?:vivante?s?|morte?s?)\b/i,
+    label: 'outil "vivant/mort"',
+    good: 'le fait observe : "repond" / "ne repond pas" + le resultat exact',
+  },
 ]);
 
 // A word boundary that treats accented letters as part of a word, so \btier\b

package/install/templates/.claude/rules/native-workflows.md

@@ -26,7 +26,8 @@ A native workflow script mutates FD/strict state only through the `byan_fd_*` /
 
 Each `agent()` leaf runs on the session model unless the call sets `opts.model`.
 The tiering decision lives in one place — `_byan/mcp/byan-mcp-server/lib/native-tiers.js`
-(tier vocabulary, leaf classifier, model map). Three tiers:
+(tier vocabulary, leaf classifier, model map). Three AUTO-routed tiers, plus an
+explicit UP-TIER an author may pin by complexity (v3):
 
 - **cheap (`model: 'haiku'`)** — a pure EXPLORATION leaf (read/load/parse/detect).
 - **balanced (`model: 'sonnet'`)** — two classes land here. (1) MECHANICAL
@@ -40,16 +41,25 @@ The tiering decision lives in one place — `_byan/mcp/byan-mcp-server/lib/nativ
   leaf may carry `model: 'sonnet'` (its tier) but not `haiku` (`analysis-below-tier`).
   Semantic/adversarial VERIFICATION is NOT analysis and stays deep.
 - **deep (OMIT `opts.model`)** — implementation + verification leaves inherit the
-  session model (no pin-up to opus). A genuinely frontier ANALYSIS leaf opts back to
-  deep with the `deep-` label prefix (`deep-assess-architecture`), the mirror of the
-  `mech-` opt-in.
+  session model (the cost-safe default: no AUTO pin-up). A genuinely frontier
+  ANALYSIS leaf opts back to deep with the `deep-` label prefix
+  (`deep-assess-architecture`), the mirror of the `mech-` opt-in.
+- **up-tier (`model: 'opus'` / `model: 'fable'`)** — an EXPLICIT authoring choice
+  to raise a genuinely complex leaf ABOVE the inherited tier (v3). `opus` for a
+  hard leaf, `fable` as the last-resort top-reasoning model for extreme complexity
+  (~2x Opus price). This is the workflow-leaf mirror of the dispatch-router
+  complexity ladder (haiku -> sonnet -> opus -> fable). Auto-routing does not pick
+  it — the author writes it deliberately. The anti-downgrade floor does not apply
+  upward, so the linter allows an up-tier pin on any leaf (it costs more, it does
+  not regress quality). The old blanket "no pin-up / no Fable" ban is lifted.
 
 The linter splits the two directions:
 
-- **Floor (HARD, blocks the commit)** — a downgrade model on a PROTECTED leaf, a
-  pin-up, or a half-applied `mech-` opt-in is a contract violation
+- **Floor (HARD, blocks the commit)** — a DOWNGRADE model (haiku/sonnet) on a
+  PROTECTED leaf, or a half-applied `mech-` opt-in, is a contract violation
   (`modelRoutingViolations` + `mechanicalLabelViolations`). This is the STRICT-2
-  No Downgrade net.
+  No Downgrade net. An UP-TIER pin (opus/fable) is not a violation — the floor
+  guards downward only.
 - **Ceiling (ADVISORY, non-blocking)** — an exploration- OR analysis-labelled leaf
   that runs deep is *reported* (`byan-lint-workflows.js --advise`:
   `untiered-exploration` -> `model: 'haiku'`, `untiered-analysis` -> `model: 'sonnet'`),

package/install/templates/.claude/rules/plain-language.md

@@ -41,7 +41,25 @@ rappel des récidivistes connus.
 | gate | point de contrôle / porte |
 | leaf | étape / tâche |
 | tier | niveau / gamme |
+| nudge | rappel / conseil injecté |
+| up-tier | monter en gamme |
+| ladder | échelle |
+| rung | palier |
+| runtime | moteur d'exécution |
 | "forger" un token | générer / créer un token |
+| un outil/MCP/serveur "vivant" ou "mort" | le fait observé : "répond" / "ne répond pas" + le résultat exact |
+
+## Précision factuelle (le fond, pas seulement la forme)
+
+Le langage clair ne suffit pas s'il reste vague. Deux obligations :
+
+1. **Zéro anthropomorphisme d'outil.** Un MCP, un serveur, un hook n'est ni
+   "vivant", ni "mort", ni "content". Dis le fait observé : "`byan_ping` a
+   répondu en 0.3s", "le serveur ne répond pas (timeout 8s)".
+2. **Un état = une observation nommée.** Toute affirmation sur l'état d'un outil
+   ou d'un résultat nomme l'outil, l'appel effectué et la valeur retournée —
+   pas un résumé flou ("ça marche", "il monte pas"). Si tu n'as pas fait
+   l'appel, dis-le : "non vérifié".
 
 ## Le mécanisme (comment c'est tenu, sans boucle de réécriture)
 

package/install/templates/.claude/skills/byan-byan/SKILL.md

@@ -21,8 +21,10 @@ the user should not have to ask for it. Four moments:
    (`_byan/mcp/byan-mcp-server/lib/agent-matcher.js`), the right model + effort
    (`dispatch-router.js` / native-tiers), and the right runtime — Codex for
    execution / shell / deploy / devops / browser ; Claude for architecture /
-   refactor / quality / planning ; verification stays on Claude ; Fable is not
-   emitted. No user ask. A suited agent -> use it. NO suited agent -> interview to
+   refactor / quality / planning ; verification stays on Claude. The Claude model
+   scales on a four-rung complexity ladder (haiku -> sonnet -> opus -> fable, fable
+   the extreme last resort) ; Fable is refused on the Codex path only. No user ask.
+   A suited agent -> use it. NO suited agent -> interview to
    frame the need, web-research the trade's competencies + best practices, create
    the tailored agent (the one place the human is required upstream).
 3. **Execute in party-mode with a live visual.** The user SEES what happens, live:
@@ -30,13 +32,17 @@ the user should not have to ask for it. Four moments:
    `TaskCreate` / `TaskUpdate`) plus the dispatch table shown at the top of BUILD.
    - **Codex-lane** — when the lane is ARMED (yanstaller option on AND Codex
      linked, i.e. `_byan/_config/autodelegate.json` present with `enabled:true`
-     AND `~/.codex/auth.json` or `CODEX_API_KEY`) and the task is delegable,
+     AND `~/.codex/auth.json` or `CODEX_API_KEY`) and the task is delegable code,
      ACTUALLY delegate via `codex-bridge.js` (`codex exec` -> unified diff -> YOU
-     apply it). Fall back to Claude if Codex is unavailable. When armed, the
-     injected `[BYAN auto-delegate]` note is a DIRECTIVE, not a mere suggestion:
-     you delegate the delegable work rather than doing it on Claude by default.
-     When NOT armed (option off or Codex not linked), there is no delegation —
-     you run it on Claude.
+     apply it) or the `codex:codex-rescue` agent. This is a DIRECTIVE, enforced by
+     the `codex-delegate-guard` PreToolUse tooth : it DENIES a delegable code
+     Write/Edit that skipped Codex. The ONLY valid reasons to stay on Claude are
+     (1) Codex unavailable (auto-detected), or (2) the USER asked to stay on Claude
+     ("reste sur Claude" / "sans codex", or the `.byan-codex-autodelegate/off`
+     switch). "Small script / latency / I verify anyway" is NOT valid — that is
+     exactly the self-dodge the tooth closes (option B). You cannot self-grant a
+     bypass. When NOT armed (option off or Codex not linked), there is no
+     delegation — you run it on Claude.
    - **Claude-lane** — run it on Claude at the chosen model.
 4. **User gate at the END.** The user-validation gate lands at the end, once the
    feature/task is done and there is a deliverable to review — not upstream. (In a
@@ -56,6 +62,33 @@ net (`agent-gate-check.js`) at turn end — not a guarantee enforced before disp
 Full doctrine + runtime routing table: see @.claude/rules/agent-entry-gate.md and
 @docs/intelligent-dispatch.md
 
+## 0.5. Rail natif automatique — byan-auto-dispatch (OBLIGATOIRE)
+
+A CHAQUE tache non-conversationnelle recue par /byan-byan, le dispatch et
+l'execution passent par le workflow natif — SANS que l'utilisateur le demande :
+
+1. Appelle l'outil **Workflow** avec
+   `{ scriptPath: '.claude/workflows/byan-auto-dispatch.js', args: { task: <la demande, verbatim>, stamp: <horodatage ISO courant> } }`.
+   Ne demande pas la permission de le lancer ; ne substitue pas une execution
+   directe main-thread au workflow.
+2. Le workflow fait tout le rail : il decoupe la tache en etapes typees, route
+   chaque etape sur le bon modele (echelle par complexite : haiku < 34,
+   sonnet < 67, opus < 90, fable >= 90 ; moteur Codex pour shell/deploiement
+   avec repli Claude ; la verification reste sur le modele de session), ecrit
+   `_byan-output/plan.md`, execute chaque etape sur le modele route, verifie.
+3. Au retour : montre la table etape x nature x complexite x moteur x modele,
+   le verdict de verification, et pointe `_byan-output/plan.md`. Le gate
+   utilisateur est EN FIN, sur le livrable.
+4. **Exceptions** (les seules) : une question simple / de la conversation ->
+   reponds directement ; une action destructive -> confirme d'abord ; un FD
+   multi-feature deja engage -> la phase DISPATCH du FD prend le dessus (elle
+   peut invoquer ce meme workflow feature par feature) ; l'utilisateur demande
+   explicitement une execution directe sans workflow.
+
+Note honnete : l'outil Workflow peut demander une autorisation a l'invocation
+selon le mode de permissions de la session — c'est le harnais qui la pose, pas
+toi ; ne la re-demande pas en plus.
+
 ## 1. Activation triggers
 
 Invoke this protocol when the user :
@@ -129,13 +162,14 @@ Never call `byan_update_apply` without explicit user consent. That tool returns
     - nature `exploration` (load/read/scan/list/parse/fetch...) → `haiku`
     - nature `mechanical` (binary judgment-free checks : JSON parses, schema matches, lint passes — label prefix `mech-`, explicit opt-in only) → `sonnet`
     - nature `implementation` / `verification` / `analysis` / unknown → deep = **inherit the session model**
-    - Keep protected work (verify/analysis/implement) off haiku/sonnet regardless of size ; no pin-up to opus. Pass an explicit `nature` to `byan_dispatch` when you know it.
+    - Keep protected work (verify/analysis/implement) off haiku/sonnet regardless of size. Auto-routing does not pin up ; but an author MAY deliberately UP-TIER a genuinely complex leaf to `opus` (hard) or `fable` (extreme, last resort) — the linter allows it (the floor guards downward only). Pass an explicit `nature` to `byan_dispatch` when you know it.
   - **Inside native workflow scripts** (`.claude/workflows/*.js` OR ad-hoc) the SAME tiering applies per `agent()` leaf via `opts.model`, enforced as a FLOOR not a ceiling on TWO nets :
-    - **Repo linter** (committed scripts, pre-commit) : `modelRoutingViolations` HARD-blocks a downgrade on a protected leaf, a pin-up, or a half-applied `mech-` opt-in (`mechanical-without-model` / `mechanical-below-tier`) ; an exploration-labelled leaf left deep is a NON-blocking ADVISORY (`byan-lint-workflows.js --advise`), since many such leaves bear a gate/classification/exact-conversion and must stay deep — the human owns that call.
+    - **Repo linter** (committed scripts, pre-commit) : `modelRoutingViolations` HARD-blocks a downgrade (haiku/sonnet) on a protected leaf, or a half-applied `mech-` opt-in (`mechanical-without-model` / `mechanical-below-tier`) ; an UP-TIER pin (opus/fable) is allowed, not blocked (the floor guards downward only) ; an exploration-labelled leaf left deep is a NON-blocking ADVISORY (`byan-lint-workflows.js --advise`), since many such leaves bear a gate/classification/exact-conversion and must stay deep — the human owns that call.
     - **Tier gate hook** (EVERY Workflow invocation, inline or scriptPath) : `tier-script-guard.js` (PreToolUse) runs the same analysis (`lib/tier-script.js`) and DENIES ONCE when exploration/`mech-` leaves have no tier, with the exact leaf list to fix. Acknowledge deliberate deep choices with the `// BYAN-TIER: reviewed` comment marker ; an identical resubmission passes (deny-once by design, no trap). Every decision lands in `_byan-output/tier-ledger.jsonl` (the measurement basis for token gains). Escape hatch : `.byan-tier/off`.
     - **Authoring aid** : BEFORE writing a script, call `byan_dispatch` with `{ leaves: [{ label, nature? }] }` (batch mode) to get the `opts.model` per leaf ; write `model:` only where non-null. Report with `node _byan/mcp/byan-mcp-server/bin/byan-tier-script.js <file> [--json]`.
     - No per-leaf effort knob exists (the API exposes only `model`), so effort-by-complexity reduces to model-by-complexity.
 - **Output** : a table `{ feature → specialist → model → strategy → estimated_tokens }`.
+- **Execution engine per feature** : le workflow natif `byan-auto-dispatch` (section 0.5) prend la feature comme `task` — meme decoupage, meme echelle de modeles, meme plan.md. Repartition des roles : `byan-hermes-dispatch` reste l'ORCHESTRATEUR du BUILD (phase 5) ; `byan-auto-dispatch` est le MOTEUR qu'il peut invoquer par feature (une invocation Workflow = une feature). Pas deux pilotes : un orchestrateur, un moteur.
 - **If no specialist matches** : halt. Ask user whether to run INT (agent recruitment) first. Do NOT fallback silently to general-purpose.
 - **Exit gate** : user validates the mapping.