create-byan-agent 2.48.0 → 2.49.0

package/CHANGELOG.md

@@ -9,6 +9,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.49.0] - 2026-07-16
+
+### Added
+- Chaine d'entree BYAN v2 dans le skill `byan-byan` (section 0) : comprendre la
+  demande -> point de controle de plan uniquement sur doute -> dispatch Hermes
+  automatique (agent + modele + effort) -> execution party-mode avec visuel live
+  -> point de controle utilisateur en fin. L'humain reste requis seulement pour
+  creer un nouvel agent, confirmer un destructif, ou trancher un plan en cas de
+  doute.
+- Visuel party-mode cable sur la liste de taches native (une entree par
+  agent/etape, `TaskCreate` / `TaskUpdate` en direct) plus la table de dispatch
+  affichee en tete de la phase BUILD.
+- Garde "les deux moteurs" (`codexLinked()`) dans `codex-autodelegate.js` : la
+  voie Codex ne s'arme que si l'option yanstaller est activee ET Codex est linke
+  (`~/.codex/auth.json` ou `CODEX_API_KEY`) ; option seule = pas de delegation.
+
+### Changed
+- La delegation Codex sur voie armee passe de "conseil advisory" a "directive" :
+  quand la voie est armee (option + les deux moteurs), le rendu injecte demande
+  de deleguer le delegable via `codex-bridge` (repli Claude si Codex
+  indisponible), au lieu de laisser BYAN executer sur Claude par defaut.
+- Doctrine synchronisee (`.claude/rules/agent-entry-gate.md`, `.claude/CLAUDE.md`)
+  a la chaine d'entree v2 ; la double validation est calibree (doute / nouvel
+  agent / destructif) au lieu d'un reflexe a chaque tache.
+
+### Docs
+- `docs/codex-auto-delegation.md` : garde "les deux moteurs", directive-quand-arme,
+  plafond honnete.
+- `docs/per-platform-projection-opti.md` : chantier suivant planifie (coeur unique
+  + deux projections optimisees par plateforme Claude/Codex, sans source rivale).
+
 ## [2.48.0] - 2026-07-16
 
 ### Added - The whole dispatch chain now runs automatically at the entry

package/install/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.37.1",
+  "version": "2.49.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/CLAUDE.md

@@ -17,19 +17,27 @@ Voir @.claude/rules/hermes-dispatcher.md pour les commandes Hermes.
 
 ## Porte d'entree — dispatch d'agent obligatoire (match-or-create)
 
-La base de BYAN : toute tache non-conversationnelle passe d'abord par le dispatch
-d'agent. BYAN + Hermes evaluent quel agent specialiste colle au besoin et le
-PROPOSENT ; l'utilisateur valide (double validation IA + humain), PUIS on lance le
-workflow. Aucun agent adapte -> interview pour cadrer le besoin -> recherche web
-(competences + bonnes pratiques du metier) -> creation de l'agent sur mesure ->
-workflow. Le declencheur de l'interview est l'absence d'un agent adapte, pas la
-taille de la tache.
-
-A l'entree, BYAN enchaine AUTOMATIQUEMENT toute la chaine, sans que tu la
-demandes : (1) quel agent, (2) quel moteur — Codex pour execution/shell/deploy/
-devops/navigateur, Claude sinon (via `dispatch-router`), (3) execution, avec
-delegation reelle a Codex sur sa voie. L'humain reste requis seulement pour creer
-un nouvel agent et confirmer une action destructive. Detail + enforcement : voir
+La base de BYAN : toute tache non-conversationnelle passe d'abord par la chaine
+d'entree. A l'entree, BYAN enchaine AUTOMATIQUEMENT toute la chaine, sans que tu
+la demandes — quatre moments :
+
+1. **Comprendre.** Demande claire -> on avance directement, zero question. Doute
+   ou demande mal exprimee -> BYAN expose UN plan clair (quels agents, quels
+   modeles, quel effort) et tu tranches. Ce point de controle en amont ne se
+   declenche que sur un vrai doute.
+2. **Dispatch (Hermes, automatique).** Le bon agent, le bon modele, le bon effort,
+   le bon moteur — Codex pour execution/shell/deploy/devops/navigateur, Claude
+   sinon (via `dispatch-router`). Aucun agent adapte -> interview + recherche web
+   (competences + bonnes pratiques du metier) -> creation de l'agent sur mesure.
+3. **Execution en party-mode avec visuel live.** Tu vois ce qui se passe en
+   direct (liste de taches native + table de dispatch). Voie Codex armee (option
+   yanstaller + Codex linke) + tache delegable -> delegation reelle a Codex ;
+   sinon execution sur Claude.
+4. **Gate en fin.** La validation utilisateur arrive a la fin, sur le livrable —
+   pas en amont.
+
+L'humain reste requis seulement pour : creer un nouvel agent, confirmer une action
+destructive, trancher le plan quand il y a doute. Detail + enforcement : voir
 @.claude/rules/agent-entry-gate.md et @docs/intelligent-dispatch.md
 
 ## Architecture BYAN

package/install/templates/.claude/hooks/codex-autodelegate.js

@@ -20,6 +20,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const { readStdin, parseJson } = require('./lib/strict-runtime');
 const { decideAutodelegation, renderNudge } = require('./lib/autodelegate-decision');
 const { estimateClaudeUsage } = require('./lib/usage-estimator');
@@ -44,13 +45,29 @@ function toggledOff(projectRoot) {
   }
 }
 
+// The "both engines present" gate. The lane arms only when the yanstaller option
+// wrote enabled:true (checked via loadConfig) AND Codex is actually linked on this
+// machine — a ChatGPT subscription via `codex login` (~/.codex/auth.json) or
+// CODEX_API_KEY. Option on but no linked Codex = one engine only = no delegation
+// (the user's rule: option AND both engines, else nothing). Mirrors codexAuthState
+// in install/lib/codex-autodelegate-setup.js.
+function codexLinked({ home = os.homedir() } = {}) {
+  if (process.env.CODEX_API_KEY) return true;
+  try {
+    return fs.existsSync(path.join(home, '.codex', 'auth.json'));
+  } catch {
+    return false;
+  }
+}
+
 if (require.main === module) {
   (async () => {
     let additionalContext = '';
     try {
       const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.cwd();
       const config = loadConfig(projectRoot);
-      if (config.enabled === true && !toggledOff(projectRoot)) {
+      // Both engines must be present : option armed (enabled) AND Codex linked.
+      if (config.enabled === true && !toggledOff(projectRoot) && codexLinked()) {
         const payload = parseJson(await readStdin());
         const prompt = payload.prompt || payload.user_prompt || payload.userPrompt || '';
         // Estimate usage only when a budget is configured; else pct stays null and
@@ -71,4 +88,4 @@ if (require.main === module) {
   })();
 }
 
-module.exports = { loadConfig, toggledOff };
+module.exports = { loadConfig, toggledOff, codexLinked };

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

@@ -123,22 +123,26 @@ function sanitizeForContext(value, max = 120) {
 }
 
 // Render a decision into the one-paragraph nudge injected into BYAN's context.
-// Empty string when there is nothing to propose (so the hook injects nothing).
-// The nudge is ADVISORY: it proposes, it never forces — BYAN still owns the call
-// and the red line is spelled out every time.
+// Empty string when there is nothing to render (so the hook injects nothing).
+// The hook injects this ONLY when the lane is armed (option on AND Codex linked),
+// so the text is a DIRECTIVE, not advice: delegate the delegable part, fall back
+// to Claude only if Codex is unavailable. The red line (delegable work only —
+// judgment/soul/verify stay on Claude) is spelled out every time.
 function renderNudge(decision) {
   if (!decision || !decision.delegate) return '';
   const gauge = decision.pct != null ? ` (estimated Claude 5h usage ~${decision.pct}%)` : '';
   const invocation = sanitizeForContext(decision.invocation) || DEFAULT_INVOCATION;
   const scope = decision.mode === 'all'
-    ? 'Consider offloading ALL delegable work this session to Codex'
+    ? 'Delegate ALL delegable work this session to Codex'
     : decision.mode === 'perf-routed'
-      ? 'Codex is heuristically favored for this kind of task (not a measured benchmark) — consider handing it over'
-      : 'This looks like delegable coding work — consider handing it to Codex';
+      ? 'Codex is heuristically favored for this kind of task (not a measured benchmark) — delegate it'
+      : 'This is delegable coding work — delegate it to Codex';
   return [
     `[BYAN auto-delegate]${gauge}: ${scope} via \`${invocation}\` `
       + '(runs on the ChatGPT subscription, no API credit).',
-    `Red line: ${decision.redLine}. This is advisory — you decide, and you still verify Codex's output before commit.`,
+    `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.",
   ].join(' ');
 }
 

package/install/templates/.claude/rules/agent-entry-gate.md

@@ -47,35 +47,55 @@ declencher une interview a chaque fois. Agent existant qui colle = on route
 direct. Besoin flou ou aucun agent adapte = la ou l'interview + creation se
 declenchent. La ceremonie est proportionnee au manque, pas systematique.
 
-## La chaine complete, automatique (agent -> moteur -> execution)
+## La chaine complete, automatique (comprendre -> dispatch -> execution party-mode -> gate en fin)
 
 Le dispatch d'agent n'est que la premiere marche. A l'entree, sur toute tache,
 BYAN enchaine la chaine ENTIERE de lui-meme, sans que l'utilisateur ait a la
-demander :
-
-1. **Agent** — matcher (ci-dessus). Fit -> cet agent ; no-fit -> interview +
-   recherche web + creation. Seul point ou l'humain reste requis : creer un
-   nouvel agent.
-2. **Moteur** — router via `_byan/mcp/byan-mcp-server/lib/dispatch-router.js` :
-   Codex pour execution / shell / deploiement / devops / navigateur ; Claude pour
-   architecture / refactor / qualite / planif ; la verification reste sur Claude ;
-   Fable n'est pas emis ; modele + effort selon la complexite. Decision
-   automatique, pas de validation utilisateur.
-3. **Execution** — Codex-lane : deleguer a Codex via le pont
-   (`lib/codex-bridge.js` : `codex exec` -> diff unifie -> Claude applique le
-   diff ; repli sur Claude si Codex est indisponible). Claude-lane : executer sur
-   Claude au modele choisi. Automatique.
+demander. Quatre moments :
+
+1. **Comprendre la demande.** Demande claire -> on avance directement, sans
+   question. Doute ou demande mal exprimee -> BYAN expose UN plan clair (quels
+   agents, quels modeles, quel effort) et l'utilisateur tranche. Ce point de
+   controle en amont ne se declenche que sur un vrai doute — pas en reflexe a
+   chaque tache.
+2. **Dispatch (Hermes, automatique).** Le bon agent (matcher
+   `_byan/mcp/byan-mcp-server/lib/agent-matcher.js`), le bon modele + effort
+   (`dispatch-router.js` / native-tiers) et le bon moteur : Codex pour execution /
+   shell / deploiement / devops / navigateur ; Claude pour architecture / refactor
+   / qualite / planif ; la verification reste sur Claude ; Fable n'est pas emis.
+   Decision automatique, pas de validation utilisateur. Fit -> cet agent ;
+   no-fit -> interview + recherche web + creation (seul point ou l'humain reste
+   requis en amont).
+3. **Execution en party-mode avec un visuel live.** L'utilisateur VOIT ce qui se
+   passe, en direct : la liste de taches native (une entree par agent/etape,
+   mise a jour en temps reel) plus la table de dispatch en tete. Codex-lane : quand
+   la voie est ARMEE (option yanstaller + Codex linke) et la tache delegable,
+   deleguer REELLEMENT via le pont (`lib/codex-bridge.js` : `codex exec` -> diff
+   unifie -> Claude applique ; repli sur Claude si Codex indisponible) — le conseil
+   injecte est alors une directive, pas une simple suggestion. Non armee : pas de
+   delegation, on execute sur Claude. Claude-lane : executer sur Claude au modele
+   choisi.
+4. **Gate utilisateur en fin.** Le point de controle utilisateur arrive a la fin,
+   une fois la feature/tache faite et s'il y a un livrable a valider — pas en
+   amont. Dans un FD multi-feature complet, les gates par phase s'appliquent en
+   plus (c'est la gouvernance plus lourde du FD ; le chemin direct ci-dessus est
+   le cas courant).
 
 Ce qui reste a l'humain : (a) creer un nouvel agent quand aucun ne colle, (b)
-confirmer une action destructive. Le reste — match agent, routage moteur,
-execution — part tout seul. Detail du routage moteur : `docs/intelligent-dispatch.md`.
+confirmer une action destructive, (c) trancher le plan en amont quand il y a
+doute. Le reste — comprehension, match agent, routage moteur, execution — part
+tout seul. Detail du routage moteur : `docs/intelligent-dispatch.md`.
 
-## La double validation
+## La double validation (calibree : sur doute, nouvel agent, destructif)
 
 Le matcher (F1, `_byan/mcp/byan-mcp-server/lib/agent-matcher.js`) est un
 pre-tri deterministe : il classe les candidats du roster et rend un verdict
-{fit | no-fit}. Il PROPOSE, il ne tranche pas seul. BYAN presente la proposition
-en clair ; l'utilisateur valide. IA propose, humain confirme.
+{fit | no-fit}. Il PROPOSE, il ne tranche pas seul. Mais la confirmation humaine
+n'est PAS un reflexe a chaque tache : sur une demande claire avec un agent adapte,
+BYAN route et execute, et le gate est en fin. La confirmation humaine se declenche
+sur les trois cas qui la meritent : un vrai doute (le plan en amont), la creation
+d'un nouvel agent, une action destructive. IA propose, humain confirme — la ou ca
+compte, pas partout.
 
 ## La creation d'agent enrichie (chemin no-fit)
 

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

@@ -7,31 +7,54 @@ description: BYAN — Builder of YAN. Core meta-agent that owns the Feature Deve
 
 You are BYAN when this skill is active. You own the eight-phase Feature Development workflow and you enforce it mechanically. Every new feature the user asks for goes through all phases in order. No skipping. No implicit transitions. The cycle includes a REFACTOR loop back to BUILD when VALIDATE fails.
 
-## 0. Entry gate — run the WHOLE dispatch chain automatically
-
-On EVERY non-conversational task, run this chain yourself, of your own accord —
-the user should NOT have to ask for it. Three steps, then execute:
-
-1. **Which agent** — match the need against the roster with the matcher
-   (`_byan/mcp/byan-mcp-server/lib/agent-matcher.js`). A suited agent -> use it.
-   NO suited agent -> propose an interview to frame the need, web-research the
-   trade's competencies + best practices, create the tailored agent. This is the
-   ONE step where the human stays in the loop (creating a new agent).
-2. **Which runtime** — route with `dispatch-router.js`: Codex for execution /
-   shell / deploy / devops / browser ; Claude for architecture / refactor /
-   quality / planning ; verification stays on Claude ; Fable is not emitted ;
-   model + effort scale to complexity. This decision is automatic — no user ask.
-3. **Execute** — Codex-lane: delegate to Codex via the bridge
-   (`codex-bridge.js`: `codex exec` -> unified diff -> YOU apply it ; fall back to
-   Claude if Codex is unavailable). Claude-lane: do it on Claude at the chosen
-   model. Automatic — no user ask.
-
-Proportionate: a trivial task with an existing agent routes directly, no
-ceremony. The human stays required only for (a) creating a NEW agent and (b)
-confirming a destructive action. Everything else — agent match, runtime routing,
-execution — is automatic. Do NOT do a task inline without running this chain.
-Full doctrine + the reactive net (`agent-gate-check.js`) + the runtime routing
-table: see @.claude/rules/agent-entry-gate.md and @docs/intelligent-dispatch.md
+## 0. Entry chain — comprehend, dispatch, execute in party-mode, gate at the end
+
+On every non-conversational task, run this chain yourself, of your own accord —
+the user should not have to ask for it. Four moments:
+
+1. **Comprehend the request.** Clear -> advance directly, no question. Doubt or a
+   badly-expressed request -> expose ONE clear plan (which agents, which models,
+   which effort) and let the user decide. This upstream plan-gate fires ONLY on
+   genuine doubt — it is not a reflex on every task. When the request is clear,
+   skip it and route.
+2. **Dispatch (Hermes, automatic).** Pick the right agent
+   (`_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
+   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:
+   the native task list (one entry per agent/step, updated in real time via
+   `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,
+     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.
+   - **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
+   full multi-feature FD, the per-phase gates below still apply — that is the
+   heavier governance the FD opts into; the direct path above is the common case.)
+
+Proportionate: a trivial task with an existing agent routes directly, no ceremony;
+a genuine multi-feature build escalates into the full eight-phase FD. The human
+stays required only for (a) creating a NEW agent and (b) confirming a destructive
+action. Everything else — comprehension routing, agent match, runtime routing,
+execution — is automatic. Do not do a task yourself without running this chain.
+
+**Honest ceiling.** Claude Code has no control point before a response is shown,
+so this chain is model-driven doctrine, not a hard mechanism: the delegation and
+the visual are things you DO because this section says so, backed by the reactive
+net (`agent-gate-check.js`) at turn end — not a guarantee enforced before display.
+Full doctrine + runtime routing table: see @.claude/rules/agent-entry-gate.md and
+@docs/intelligent-dispatch.md
 
 ## 1. Activation triggers
 
@@ -122,7 +145,10 @@ Never call `byan_update_apply` without explicit user consent. That tool returns
   - TDD first : write/update tests before implementation.
   - Atomic commits : `type: description`, no emoji, one feature per commit.
   - Parallel BUILD via `party-mode-native` only if roles are independent and write to non-overlapping paths.
-- **Visibility** : the `tool-transparency` hook already writes per-tool entries to `_byan-output/tool-log.jsonl`. Every sub-task you spawn must be visible there.
+- **Party-mode live visual** (the user must SEE what happens) :
+  1. At BUILD entry, print the dispatch table (feature x specialist x model x strategy) so the plan is on screen before any work starts.
+  2. Create ONE native task per feature/agent with `TaskCreate` (the checklist Claude Code renders live). Set it `in_progress` (`TaskUpdate`) with the acting agent as `owner` the moment that agent starts, and `completed` the moment it finishes. One entry per agent/step, updated in real time — that is the visual.
+  3. This native list is the primary visual ; the `tool-transparency` hook is the audit trail underneath it, writing per-tool entries to `_byan-output/tool-log.jsonl`. Every sub-task you spawn must be visible in both.
 - **Exit gate** : user sees the diff and says "ok build".
 
 ### Phase 6 — REVIEW (qualitative pre-flight + tiered adversarial second pair of eyes)

package/install/templates/_byan/mcp/byan-mcp-server/skill-bundles-manifest.json

@@ -94,7 +94,7 @@
       "name": "byan-byan",
       "module": "core",
       "tier": "connector-bound",
-      "sourceHash": "91fa54c35848f2e2ddd6210fde0f15fab53d58ce5b36627f90ebcfbf760e09a1"
+      "sourceHash": "84fa718d638f1ddb37796c9b80c702fca48350decb40979bd1adea1452224abc"
     },
     "byan-byan-v2": {
       "name": "byan-byan-v2",

package/install/templates/docs/codex-auto-delegation.md

@@ -12,9 +12,24 @@ work crosses the line.
 Every turn, a `UserPromptSubmit` hook estimates how much of the Claude 5h window
 you have burned and looks at the task you just asked for. If the task is
 delegable (code / mechanical) — or if you are over the pressure threshold — BYAN
-injects a one-line advisory nudge proposing you hand it to Codex via
-`codex:codex-rescue --model gpt-5.4`. You still decide, and you still verify
-Codex's output before commit.
+injects a one-line note directing you to hand it to Codex via
+`codex:codex-rescue --model gpt-5.4`. You still verify Codex's output before commit.
+
+**Both engines must be present.** The lane only arms — and the note only fires —
+when TWO conditions hold together: the yanstaller option wrote
+`_byan/_config/autodelegate.json` with `enabled:true`, AND Codex is actually
+linked on this machine (`~/.codex/auth.json` from `codex login`, or
+`CODEX_API_KEY`). Option on but no linked Codex = one engine only = no delegation.
+This is the runtime `codexLinked()` gate in `codex-autodelegate.js`, the mirror of
+the installer's arm-time `codexAuthState` check.
+
+**Armed = directive, not advice.** Because the note only appears when the lane is
+armed (both engines present), it reads as a directive: delegate the delegable
+part, fall back to Claude only if Codex is unavailable. When the lane is not
+armed, no note is injected and everything runs on Claude — there is nothing to
+decide. Honest ceiling: Claude Code has no control point before a response is
+shown, so this stays model-driven doctrine (BYAN delegates because the skill's
+entry chain and this note say so), not a mechanism enforced before display.
 
 Three triggers, in priority order:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.48.0",
+  "version": "2.49.0",
   "description": "BYAN v2.8 - Intelligent AI agent creator with ELO trust system + scientific fact-check + Hermes universal dispatcher + native Claude Code integration (hooks, skills, MCP server). Multi-platform (Claude Code, Codex). Merise Agile + TDD + 71 Mantras. ~54% LLM cost savings.",
   "main": "src/index.js",
   "bin": {