create-byan-agent 2.50.0 → 2.52.0

package/CHANGELOG.md

@@ -9,6 +9,65 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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/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/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/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
@@ -129,9 +135,9 @@ 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.

package/install/templates/_byan/mcp/byan-mcp-server/lib/dispatch-router.js

@@ -2,26 +2,27 @@
 // given a task's NATURE and COMPLEXITY, decide which RUNTIME runs it (Codex or
 // Claude), which MODEL, and (Codex only) which reasoning EFFORT.
 //
-// It composes with, does not duplicate, native-tiers.js: the Claude-side model
-// tier is delegated to that module's TIER_MODEL vocabulary (which, by design,
-// only ever yields haiku / sonnet / null — so Fable can never leak in from the
-// Claude side either). This module adds the two NEW axes the intelligent dispatch
-// needs — runtime selection and Codex reasoning effort — on top of it.
+// The Claude-side model is a FOUR-rung complexity ladder (v3):
+// haiku -> sonnet -> opus -> fable, fable being the last-resort top-reasoning
+// model reserved for EXTREME complexity (~2x Opus price). See
+// claudeModelForComplexity. This module adds the two NEW axes the intelligent
+// dispatch needs — runtime selection and Codex reasoning effort — on top of it.
 //
 // Routing table is the cross-checked result (5 independent sources, see
 // docs / CHANGELOG): Codex wins autonomous execution, shell/CI/DevOps, deploy,
 // browser/computer use ; Claude wins architecture, refactor-at-repo-scale,
 // quality, planning, and ALL verification. Two hard red lines are enforced here,
 // not left to the caller:
-//   1. Fable is NEVER emitted (long-term product decision).
+//   1. Fable is NEVER routed to CODEX (Codex runs the ChatGPT-subscription model,
+//      it cannot run a Claude model at all). On the CLAUDE side Fable IS allowed,
+//      but only at the extreme rung (v3 product reversal — the old blanket ban is
+//      lifted). assertNoFable therefore guards the Codex path only.
 //   2. Verification is NEVER routed to Codex (a runtime must not grade its own
 //      work ; the reviewer stays on Claude).
 //
 // Pure: no I/O, no clock, deterministic. The Codex transport (F2) and the
 // orchestrating loop (F4) consume this; they never re-decide routing.
 
-import { TIER_MODEL } from './native-tiers.js';
-
 export const RUNTIMES = Object.freeze({ CODEX: 'codex', CLAUDE: 'claude' });
 
 // Codex runs on the ChatGPT-subscription entitled model. Kept as a named constant
@@ -30,8 +31,10 @@ export const CODEX_MODEL = 'gpt-5.4';
 
 export const EFFORTS = Object.freeze({ LOW: 'low', MEDIUM: 'medium', HIGH: 'high' });
 
-// Models we refuse to emit, ever. Fable is excluded by explicit long-term
-// decision; the guard makes that refusal mechanical rather than a convention.
+// Models we refuse to emit on the CODEX path. Codex runs the ChatGPT-subscription
+// model and cannot run a Claude model — Fable on Codex is a category error, so the
+// guard makes that refusal mechanical. (On the CLAUDE path Fable is allowed at the
+// extreme rung — see claudeModelForComplexity ; this list does not gate it.)
 export const FORBIDDEN_MODELS = Object.freeze(['fable', 'claude-fable-5']);
 
 // Task natures that route to Codex. Everything NOT here (and not a verification
@@ -58,12 +61,14 @@ function matchesAny(text, list) {
   return list.some((kw) => text.includes(kw));
 }
 
-// assertNoFable(model) — mechanical enforcement of red line #1. Throws rather
-// than silently substituting, so a Fable request is a loud failure at the source.
+// assertNoFable(model) — mechanical enforcement of red line #1 on the CODEX path.
+// Throws rather than silently substituting, so a Fable-on-Codex request is a loud
+// failure at the source (Codex cannot run a Claude model). It does NOT gate the
+// Claude path, which may legitimately emit Fable at the extreme rung.
 export function assertNoFable(model) {
   const m = normalize(model);
   if (FORBIDDEN_MODELS.some((f) => m.includes(f))) {
-    throw new Error(`dispatch-router: forbidden model "${model}" (Fable is excluded by long-term policy)`);
+    throw new Error(`dispatch-router: forbidden model "${model}" on the Codex path (Codex cannot run a Claude model)`);
   }
   return model;
 }
@@ -106,28 +111,41 @@ export function effortForComplexity(complexity) {
   return complexityBucket(complexity);
 }
 
-// claudeModelForComplexity(complexity) -> 'haiku' | 'sonnet' | null(omit=inherit).
-// Delegates to native-tiers' TIER_MODEL so the Claude vocabulary stays in one
-// place: low -> cheap(haiku), medium -> balanced(sonnet), high -> deep(null =
-// inherit the session model, i.e. Opus on an Opus session). Fable is structurally
-// impossible here (TIER_MODEL has no Fable entry), but we still assert to make the
-// guarantee explicit and catch a future TIER_MODEL drift.
+// claudeModelForComplexity(complexity) -> the Claude-side model RECOMMENDATION on
+// a FOUR-rung complexity ladder (v3): haiku -> sonnet -> opus -> fable.
+//   - < 34  : haiku   (trivial / low)
+//   - < 67  : sonnet  (medium)
+//   - < 90  : opus    (high — the default frontier)
+//   - >= 90 : fable   (extreme complexity, LAST RESORT)
+// Fable is the top-reasoning model : strongest on the intelligence index but
+// ~2x the price of Opus, so it is reserved for the extreme rung only. This is a
+// per-task RECOMMENDATION consumed by the dispatch orchestrator / skill — NOT a
+// live switch of the running session model (Claude Code exposes no such switch).
+// Labels map too (trivial/low/medium/high/extreme). The old blanket "never Fable"
+// red line is lifted on the CLAUDE side (deliberate v3 product reversal); it still
+// holds on the CODEX side (see dispatch() + assertNoFable + codex-bridge).
 export function claudeModelForComplexity(complexity) {
-  const bucket = complexityBucket(complexity);
-  const model = bucket === EFFORTS.LOW
-    ? TIER_MODEL.cheap
-    : bucket === EFFORTS.MEDIUM
-      ? TIER_MODEL.balanced
-      : TIER_MODEL.deep; // null = inherit (never pinned to Fable)
-  return model == null ? null : assertNoFable(model);
+  if (typeof complexity === 'number' && Number.isFinite(complexity)) {
+    if (complexity < 34) return 'haiku';
+    if (complexity < 67) return 'sonnet';
+    if (complexity < 90) return 'opus';
+    return 'fable';
+  }
+  const c = normalize(complexity);
+  if (['trivial', 'low', 'simple', 'easy'].includes(c)) return 'haiku';
+  if (['medium', 'moderate'].includes(c)) return 'sonnet';
+  if (['extreme', 'frontier', 'max'].includes(c)) return 'fable';
+  if (['high', 'hard', 'complex'].includes(c)) return 'opus';
+  return 'sonnet'; // unknown -> a safe middle
 }
 
 // dispatch({ nature, complexity }) -> the full routing decision:
 //   { runtime, model, effort, reasoning }
 // - Codex: model = CODEX_MODEL, effort = complexity bucket (the real knob).
-// - Claude: model = haiku/sonnet/null(inherit), effort = null (Claude has no
-//   effort knob — its "effort" IS the model tier).
-// Both red lines are enforced here regardless of caller input.
+// - Claude: model = haiku/sonnet/opus/fable on the complexity ladder, effort =
+//   null (Claude has no effort knob — its "effort" IS the model tier).
+// The red lines are enforced here regardless of caller input: Codex keeps its
+// no-Fable guard ; verification stays on Claude.
 export function dispatch({ nature, complexity } = {}) {
   const runtime = routeRuntime(nature);
   if (runtime === RUNTIMES.CODEX) {
@@ -140,7 +158,7 @@ export function dispatch({ nature, complexity } = {}) {
   }
   return {
     runtime,
-    model: claudeModelForComplexity(complexity), // null = inherit session model
+    model: claudeModelForComplexity(complexity), // haiku/sonnet/opus/fable by complexity
     effort: null, // Claude effort = model tier, no separate knob
     reasoning: isVerification(nature)
       ? 'verification stays on Claude (red line: a runtime never grades its own work)'

package/install/templates/_byan/mcp/byan-mcp-server/lib/native-tiers.js

@@ -40,6 +40,17 @@ export const TIERS = Object.freeze({ CHEAP: 'cheap', BALANCED: 'balanced', DEEP:
 // flags every script literal that drifts from it, so the fan-out stays bounded.
 export const TIER_MODEL = Object.freeze({ cheap: 'haiku', balanced: 'sonnet', deep: null });
 
+// UP-TIER models (v3). The auto-routing above never pins UP (the default stays
+// cost-safe: deep = inherit the session model). But an author MAY deliberately
+// raise a genuinely complex leaf ABOVE the inherited tier — '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). Up-tier pins are an
+// explicit authoring choice: the anti-DOWNGRADE floor does not apply upward, so
+// the linter ALLOWS them (they cost more, they never regress quality). The old
+// blanket "never pin up / never Fable" ban on leaves is lifted here.
+export const UP_TIER_MODELS = Object.freeze(['opus', 'fable']);
+
 // Leaf task-type taxonomy. EXPLORATION (cheap) and MECHANICAL + ANALYSIS
 // (balanced) are the downgrade classes; VERIFICATION and IMPLEMENTATION stay
 // protected (deep, inherit the session model). MECHANICAL is verification whose
@@ -130,18 +141,26 @@ export function modelForLeaf(leaf) {
   return TIER_MODEL[tierFor(classifyLeaf(leaf))];
 }
 
-// isKnownTierModel(modelId) -> true if modelId is one of the concrete downgrade
-// models (cheap/balanced). Used by the linter to reject an opts.model literal
-// that is not a recognised tier. null/'' are not "known" (deep = omission, not a
-// literal). 'opus' is intentionally NOT known — we never pin up.
+// isUpTierModel(modelId) -> true if modelId pins a leaf ABOVE the inherited tier
+// (opus or fable). An explicit, allowed authoring choice for a genuinely complex
+// leaf (v3): the anti-downgrade floor does not apply upward.
+export function isUpTierModel(modelId) {
+  return !!modelId && UP_TIER_MODELS.includes(modelId);
+}
+
+// isKnownTierModel(modelId) -> true if modelId is a recognised tier literal:
+// a downgrade model (cheap/balanced = haiku/sonnet) OR an up-tier model
+// (opus/fable). Used by the linter to reject an opts.model literal that is not in
+// the vocabulary at all. null/'' are not "known" (deep = omission, not a literal).
 export function isKnownTierModel(modelId) {
   if (!modelId) return false;
-  return Object.values(TIER_MODEL).filter(Boolean).includes(modelId);
+  return Object.values(TIER_MODEL).filter(Boolean).includes(modelId) || isUpTierModel(modelId);
 }
 
 // isDowngradeModel(modelId) -> true if modelId pins a leaf BELOW the inherited
 // tier (cheap or balanced). The linter's anti-downgrade rule uses this: a
-// protected leaf must never carry a downgrade model.
+// protected leaf must never carry a downgrade model. Up-tier models return false
+// (they are not downgrades — see isUpTierModel).
 export function isDowngradeModel(modelId) {
   return modelId === TIER_MODEL.cheap || modelId === TIER_MODEL.balanced;
 }

package/install/templates/_byan/mcp/byan-mcp-server/lib/tier-script.js

@@ -15,7 +15,7 @@
 // passes — the gate forces a decision, it does not trap the turn.
 
 import crypto from 'node:crypto';
-import { classifyLeaf, tierFor, TIER_MODEL, TIERS, LEAF_TYPES } from './native-tiers.js';
+import { classifyLeaf, tierFor, TIER_MODEL, TIERS, LEAF_TYPES, isUpTierModel } from './native-tiers.js';
 import { stripComments, extractLabelledLeaves } from './workflows-lint.js';
 
 // Acknowledgment marker, raw-text (comment form survives comment-stripping
@@ -26,15 +26,19 @@ export const ACK_RE = /BYAN-TIER:\s*reviewed\b/;
 
 function verdictFor(cls, model) {
   const expected = TIER_MODEL[tierFor(cls)]; // 'haiku' | 'sonnet' | null (inherit)
+  // Up-tier pins (opus/fable) are always allowed (v3): the author deliberately
+  // raises a complex leaf ABOVE the inherited tier. The anti-DOWNGRADE floor does
+  // not apply upward — it costs more but never regresses quality.
+  if (isUpTierModel(model)) return 'ok';
   if (expected === null) {
-    // Protected class: any pinned model is a downgrade or a pin-up — both wrong.
+    // Protected class: a downgrade pin is still wrong (up-tier handled above).
     return model === null ? 'ok' : 'violation';
   }
   if (model === null) return 'missing-tier';
   if (model === expected) return 'ok';
   // Exploration may ride ABOVE its floor (sonnet on a cheap leaf wastes a
-  // little, breaks nothing). Anything else — haiku on mech-, opus anywhere —
-  // is below a declared tier or an unknown pin.
+  // little, breaks nothing). Anything else — haiku on mech- — is below a
+  // declared tier.
   if (cls === LEAF_TYPES.EXPLORATION && model === TIER_MODEL[TIERS.BALANCED]) return 'ok';
   return 'violation';
 }

package/install/templates/_byan/mcp/byan-mcp-server/lib/workflows-lint.js

@@ -153,10 +153,15 @@ export function modelRoutingViolations(src) {
     if (!isKnownTierModel(model)) {
       out.push({
         id: 'unknown-tier-model',
-        msg: `opts.model '${model}' is not a known downgrade tier (cheap/balanced); never pin up — omit opts.model to inherit the session model on deep leaves`,
+        msg: `opts.model '${model}' is not a recognised tier (downgrade: haiku/sonnet ; up-tier: opus/fable); omit opts.model to inherit the session model on deep leaves`,
       });
       continue;
     }
+    // Up-tier pins (opus/fable) are an allowed explicit authoring choice: they
+    // raise a complex leaf ABOVE the inherited tier. The anti-downgrade floor does
+    // not apply upward, and no label is required (v3). Only DOWNGRADES are gated
+    // below.
+    if (!isDowngradeModel(model)) continue;
     const label = nearestLabelBefore(code, m.index);
     if (!label) {
       out.push({
@@ -165,7 +170,6 @@ export function modelRoutingViolations(src) {
       });
       continue;
     }
-    if (!isDowngradeModel(model)) continue;
     // Per-class floor: exploration accepts any downgrade tier (haiku or sonnet,
     // both at-or-above its cheap floor); a mech- leaf accepts exactly the
     // balanced tier (haiku would sit BELOW the tier its label declares); every

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": "84fa718d638f1ddb37796c9b80c702fca48350decb40979bd1adea1452224abc"
+      "sourceHash": "fcea02854887283c8ff1d4b7d09778d62fc7ce52959a00577e87091e7c31f991"
     },
     "byan-byan-v2": {
       "name": "byan-byan-v2",

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

@@ -10,11 +10,23 @@ work crosses the line.
 ## What it does
 
 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 note directing you to hand it to Codex via
+you have burned. When you are over the pressure threshold (default **75%**), BYAN
+injects a one-line note directing you to hand the delegable work to Codex via
 `codex:codex-rescue --model gpt-5.4`. You still verify Codex's output before commit.
 
+**v3 — pressure-only, and the router decides Codex vs Claude.** Two deliberate
+changes from v2:
+
+- **Pressure is the only auto-trigger (F1).** A delegable-looking task no longer
+  proposes Codex on its own. Delegating to the subscription Codex (which trails
+  Claude on quality — see below) is worth it to SPARE the Claude budget, not per
+  coding task. So off-pressure, code runs on Claude with no nag.
+- **The guard obeys the router (F2).** WHERE a task runs (Codex vs Claude) is the
+  `dispatch-router`'s call, by task nature: execution / shell / deploy / devops /
+  browser -> Codex ; architecture / refactor / quality / planning + all
+  verification -> Claude. The delegation guard only bites for a task the router
+  itself routes to Codex.
+
 **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
@@ -23,25 +35,38 @@ linked on this machine (`~/.codex/auth.json` from `codex login`, or
 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:
-
-1. **Pressure** — estimated Claude 5h usage `>= threshold` (default **80%**) ->
-   propose offloading **everything** delegable this session.
-2. **Nature** — the request looks like delegable coding work -> propose handing
-   **that** task over. Works with no gauge at all.
-3. **Perf** (opt-in, off by default) — a configurable forces table says Codex is
+**Armed = directive, enforced by a guard (option B + v3).** Because the note only
+appears when the lane is armed (both engines present), it reads as a directive:
+delegate the delegable part. And it is not just prose — the `codex-delegate-guard`
+PreToolUse hook DENIES a **code** Write/Edit that skipped Codex, but ONLY when all
+of these hold together (v3): the lane is armed, the ROUTER routes this task to
+Codex, you are under budget PRESSURE, and Codex is available. Miss any one and it
+allows. The two per-turn ways to stay on Claude are (1) Codex unavailable
+(auto-detected via `codex --version`), or (2) the USER opted out — the
+`.byan-codex-autodelegate/off` switch, or a phrase like "reste sur Claude" /
+"sans codex" in the request. The "small script / latency / I verify anyway"
+excuse is explicitly NOT valid: that was the self-dodge (a
+`// BYAN-DELEGATE: reviewed` marker BYAN wrote itself) that option B removed. BYAN
+can no longer self-grant a bypass; only the human can.
+
+The deny is a wall against BYAN's silent self-dodge, not a trap for the user: the
+human keeps the escape switch and the opt-out phrase, a doc/config write (not
+code) does not trip it, and off-pressure OR router-to-Claude nothing bites at all.
+Honest ceiling: Claude Code has no control point before a response is shown, so
+the *choice* to delegate stays model-driven; the guard acts one step later, at the
+Write, denying the skip.
+
+The auto-trigger, plus one opt-in:
+
+1. **Pressure (F1, the only auto-trigger)** — estimated Claude 5h usage
+   `>= threshold` (default **75%**) -> propose offloading **everything** delegable
+   this session. Needs a `budget` gauge; without one, pressure stays uncomputed
+   and nothing is proposed (documented, non-blocking).
+2. **Perf** (opt-in, off by default) — a configurable forces table says Codex is
    reputed stronger for this kind of task. See "Perf routing" below.
 
 **The red line** (held): only delegable natures are proposed. Judgment,
-analysis, soul and verification stay on Claude.
+analysis, soul and verification stay on Claude — and the router keeps them there.
 
 ## Enable it
 
@@ -97,8 +122,8 @@ pins `--model gpt-5.4`. See `src/loadbalancer/providers/codex-provider.js`
 | Key | Default | Meaning |
 |-----|---------|---------|
 | `enabled` | `true` (once written) | Master switch. Delete the file or set `false` to disarm. |
-| `threshold` | `80` | Pressure percentage that flips to "offload everything delegable". |
-| `budget` | `null` | Your plan's rough token ceiling for the 5h window. Without it, `pct` is null and only the nature trigger fires (see caveat). |
+| `threshold` | `75` | Pressure percentage that flips to "offload everything delegable" (v3: aligned with the guard's pressure floor). |
+| `budget` | `null` | Your plan's rough token ceiling for the 5h window. Without it, `pct` is null, pressure stays uncomputed, and nothing is auto-proposed (v3 pressure-only; see caveat). |
 | `invocation` | `codex:codex-rescue --model gpt-5.4` | What the nudge tells BYAN to run. |
 | `perfRouting` | `false` | Enable the perf trigger. |
 | `perfForces` | `[]` | The forces table (see below). |
@@ -114,11 +139,12 @@ without editing the config; remove it to re-enable.
   your local transcripts (`~/.claude/projects/*/*.jsonl`) over the rolling 5h
   window, weighting cache reads at 0.1 (they are billed roughly a tenth and
   repeat every turn). It is proportional, not exact — and `pct` is only computed
-  when you set a `budget`. Without a budget, delegation runs on the nature
-  trigger alone.
+  when you set a `budget`. Without a budget, pressure stays uncomputed and the
+  auto-trigger stays silent (v3 pressure-only).
 - **`~/.claude` is a native accelerator, not a source of truth** (PORTABLE-3).
-  If it is absent the estimator degrades to `pct: null` and the feature falls
-  back to nature-based delegation. The feature keeps working.
+  If it is absent the estimator degrades to `pct: null`, so pressure cannot be
+  computed and the auto-trigger stays silent. Code still runs on Claude normally;
+  the feature keeps working, it just does not auto-propose Codex.
 - **Perf routing is a heuristic below the L2 floor.** "Model X is better at task
   Y" is a performance claim; BYAN's fact-check floor for performance is L2 (a
   reproducible benchmark). A community arena such as designarena.ai is weaker

package/install/templates/docs/intelligent-dispatch.md

@@ -22,17 +22,21 @@ task-type signal is used, which is stable across sources.
 
 ## Model and effort by complexity
 
-- **Claude side**: complexity picks the model tier via `native-tiers` —
-  low -> haiku, medium -> sonnet, high -> inherit the session model (Opus). There
-  is no separate effort knob on Claude: the model tier IS the effort. Fable is
-  excluded (the router does not emit it).
+- **Claude side**: complexity picks the model on a four-rung ladder (v3) —
+  low -> haiku, medium -> sonnet, high -> opus, extreme -> fable (last resort,
+  ~2x Opus price). There is no separate effort knob on Claude: the model tier IS
+  the effort. This is a per-task RECOMMENDATION, not a live switch of the running
+  session model (Claude Code exposes no such switch).
 - **Codex side**: fixed model (`gpt-5.4`, the entitled subscription model) with a
   real reasoning-effort knob — low / medium / high — scaled to complexity via
   `codex exec -c model_reasoning_effort=...`.
 
 ## The three red lines (enforced in code, not left to the caller)
 
-1. **No Fable.** `assertNoFable` throws rather than emit a Fable model.
+1. **No Fable on Codex.** `assertNoFable` throws rather than emit a Fable model on
+   the Codex path (Codex runs the ChatGPT-subscription model and cannot run a
+   Claude model). On the Claude path Fable IS allowed, but only at the extreme
+   complexity rung (v3 product reversal — the old blanket ban is lifted).
 2. **Verification stays on Claude.** The router forces a verification nature to
    Claude ; the orchestrator re-asserts it and throws if it ever regresses.
 3. **Codex does not write.** Codex runs read-only and returns a unified diff ;

package/install/templates/docs/native-workflows-contract.md

@@ -95,16 +95,21 @@ tier vocabulary, the leaf classifier, and the model map.
 
 | Tier | `opts.model` | Used for |
 |------|--------------|----------|
+| `up-tier` | `opus` / `fable` | EXPLICIT authoring choice: raise a genuinely complex leaf above the inherited tier (opus for hard, fable for extreme, last resort) |
 | `deep` | **omitted** (inherit the session model) | implement, verify, analysis — the default |
 | `balanced` | `sonnet` | MECHANICAL verification, opt-in only via the `mech-` label prefix |
 | `cheap` | `haiku` | a pure exploration leaf: read / load / parse / detect |
 
 Three hard rules:
 
-- **No pin-up.** `deep` is an omission, not `model: 'opus'`. Omitting lets a
-  leaf inherit whatever the session runs — Opus by default, Sonnet if the user
-  chose Sonnet. Pinning a fixed high tier would override that and could silently
-  downgrade a Sonnet/Opus session's heavy leaf.
+- **No AUTO pin-up, but an explicit up-tier is allowed (v3).** Auto-routing does
+  not raise a leaf above the inherited tier: `deep` is an omission, letting a leaf
+  inherit whatever the session runs (Opus by default, Sonnet if the user chose
+  Sonnet). An author MAY still deliberately pin `opus` or `fable` on a genuinely
+  complex leaf — the workflow-leaf mirror of the dispatch-router complexity ladder
+  (haiku -> sonnet -> opus -> fable). The anti-downgrade floor does not apply
+  upward, so the linter allows an up-tier pin; the old blanket "no pin-up / no
+  Fable" ban is lifted.
 - **Only exploration and mech- downgrade.** A leaf is pinned to `cheap` only
   when it is unambiguous read/extract work. `classifyLeaf` keys off the LABEL
   (the prompt is too noisy — an exploration leaf often says "report what you

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.50.0",
+  "version": "2.52.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": {