create-byan-agent 2.60.1 → 2.60.2

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

@@ -1,4 +1,14 @@
-import { classifyLeaf, tierFor, TIER_MODEL, LEAF_TYPES } from './native-tiers.js';
+import {
+  classifyLeaf,
+  tierFor,
+  TIER_MODEL,
+  LEAF_TYPES,
+  modelForTask,
+  effortForTask,
+  tierOfModel,
+  COMPLEXITY_SOURCES,
+  PROTECTED_FLOOR_COMPLEXITY,
+} from './native-tiers.js';
 
 // byan_dispatch routes a unit of work along TWO independent axes:
 //
@@ -6,16 +16,22 @@ import { classifyLeaf, tierFor, TIER_MODEL, LEAF_TYPES } from './native-tiers.js
 //               Derived from the scalar score + parallelizable. This is
 //               dispatch's own concern: orchestration.
 //   TIER      — WHICH model the work deserves. Delegated to native-tiers (the
-//               single source of truth), keyed on the task's NATURE, never on its
-//               size. Only exploration downgrades to a cheap tier; implementation,
-//               verification, analysis (and anything unmatched) stay deep =
-//               inherit the session model. We never PIN UP to opus.
+//               single source of truth), au croisement de la NATURE et de la
+//               COMPLEXITE DECLAREE de la tache.
 //
 // Before this split the two axes were fused into one route string
 // ('mcp-worker-haiku', 'main-thread-opus'), so a short sequential task was
 // silently downgraded to haiku purely on length, and a long one was pinned up to
 // opus — exactly the size-driven mis-tiering native-tiers' anti-downgrade doctrine
-// forbids. The score still picks the strategy; the model now comes from nature.
+// forbids. The score still picks the strategy; the model comes from the crossing.
+//
+// La nature seule ne suffisait pas non plus : elle rendait le meme verdict pour
+// un hello world et pour un moteur de resolution de dependances, tous deux de
+// l'implementation, donc tous deux sur le modele de session — le plus cher. La
+// complexite tranche desormais entre les deux, mais SEULEMENT quand un appelant
+// l'a declaree. Sans elle il ne reste que la longueur du prompt, qui mesure des
+// caracteres, pas de la difficulte : la faire decider du modele reintroduirait
+// exactement la retrogradation par la taille condamnee ci-dessus.
 //
 // The dependency on native-tiers is intentional and one-directional: dispatch
 // CONSUMES the tier source of truth, it does not duplicate it. native-tiers is a
@@ -25,10 +41,9 @@ import { classifyLeaf, tierFor, TIER_MODEL, LEAF_TYPES } from './native-tiers.js
 const VALID_NATURES = new Set(Object.values(LEAF_TYPES));
 
 export function dispatch({ task, complexity, parallelizable, nature } = {}) {
-  const score =
-    typeof complexity === 'number'
-      ? complexity
-      : Math.min(100, Math.floor((task?.length || 0) / 10));
+  const declaree = typeof complexity === 'number' && Number.isFinite(complexity);
+  const score = declaree ? complexity : Math.min(100, Math.floor((task?.length || 0) / 10));
+  const complexitySource = declaree ? COMPLEXITY_SOURCES.DECLARED : COMPLEXITY_SOURCES.ESTIMATED;
   const isPar = parallelizable === true;
 
   // Axis 1 — strategy (where). Scalar, as before, minus the fused model suffix.
@@ -47,28 +62,38 @@ export function dispatch({ task, complexity, parallelizable, nature } = {}) {
     strategyReason = `score ${score} >= 40: heavy, kept in the main thread`;
   }
 
-  // Axis 2 — tier (which model). By nature, via native-tiers. An explicit, valid
-  // nature wins; otherwise classify the task text. An unknown nature falls back to
-  // classification rather than guessing, and classification's own default is
-  // IMPLEMENTATION (deep), so the conservative path is the worst case — protected
-  // work is never downgraded on a miss.
+  // Axis 2 — tier (which model). Croisement nature x complexite, via native-tiers.
+  // An explicit, valid nature wins; otherwise classify the task text. An unknown
+  // nature falls back to classification rather than guessing, and classification's
+  // own default is IMPLEMENTATION (protege), so the conservative path is the worst
+  // case — protected work is never downgraded on a miss.
   const leafType = VALID_NATURES.has(nature) ? nature : classifyLeaf({ label: task || '' });
-  const tier = tierFor(leafType);
-  const model = TIER_MODEL[tier]; // 'haiku' (exploration) or null (every other nature -> inherit session model). tierFor never auto-picks balanced/'sonnet'.
+  const model = modelForTask({ nature: leafType, complexity: score, source: complexitySource });
+  // Le niveau annonce decrit le modele REELLEMENT choisi, pas la classe theorique
+  // de la nature : sinon un verdict se contredit (tier deep + modele haiku).
+  const tier = tierOfModel(model);
 
   const tierReason =
-    model === null
-      ? `nature=${leafType} -> ${tier}: inherit the session model (protected, not downgraded)`
-      : `nature=${leafType} -> ${tier}: ${model}`;
+    complexitySource === COMPLEXITY_SOURCES.ESTIMATED
+      ? `nature=${leafType}, complexite non declaree (score ${score} devine sur la longueur du prompt) -> ${tier}: ${model === null ? 'modele de session' : model}. Passe \`complexity\` (0-100) pour activer l'echelle par complexite`
+      : `nature=${leafType} + complexite declaree ${score} -> ${tier}: ${model === null ? 'modele de session' : model}${
+          leafType === LEAF_TYPES.VERIFICATION
+            ? ' (ligne rouge: une verification ne descend jamais)'
+            : score >= PROTECTED_FLOOR_COMPLEXITY
+              ? ' (au-dessus du plancher anti-retrogradation)'
+              : ''
+        }`;
 
   // model applies to a DELEGATED strategy (subagent / mcp-worker leaf); for a
   // main-thread strategy the work runs on the session model and model is advisory.
   return {
     score,
+    complexitySource,
     strategy,
     nature: leafType,
     tier,
     model,
+    effort: effortForTask({ nature: leafType, complexity: score, source: complexitySource }),
     parallelizable: isPar,
     reasoning: `${strategyReason}. ${tierReason}.`,
   };
@@ -81,6 +106,12 @@ export function dispatch({ task, complexity, parallelizable, nature } = {}) {
 // script's concern, only WHICH model each deserves is answered. An explicit
 // valid nature wins; otherwise the label classifies; a miss stays protected
 // (implementation -> deep -> null), same conservative path as dispatch().
+//
+// Pas de croisement avec la complexite ici, volontairement : une feuille de
+// script n'en porte pas (le linter et le garde-fou d'ecriture ne voient qu'un
+// libelle), et inventer un score par feuille rouvrirait la retrogradation par la
+// taille. Le croisement appartient au dispatch de TACHE, ou un appelant peut
+// declarer la complexite.
 export function dispatchBatch(leaves) {
   if (!Array.isArray(leaves)) return [];
   return leaves.map((leaf) => {

package/install/templates/_byan/mcp/byan-mcp-server/lib/fd-ack.js

@@ -0,0 +1,75 @@
+/**
+ * L'accuse de reception des outils d'ECRITURE du cycle FD.
+ *
+ * POURQUOI, ET C'EST MESURE. Le 2026-09-01, sur une seule session :
+ * byan_fd_update et byan_fd_advance ont rendu 43 130 jetons pour 17 appels,
+ * soit 38 % de tout ce qui est revenu d'un outil ce jour-la. Chaque ecriture
+ * renvoyait l'etat ENTIER — backlog redige, idees brutes, table de dispatch,
+ * notes, historique des phases — et en plus mis en forme sur deux espaces.
+ *
+ * Or celui qui ecrit vient de composer cet etat : le lui relire en entier ne
+ * lui apprend rien. Ce qu'il a besoin de savoir tient en trois lignes : ou en
+ * est le cycle, combien d'items restent, et ce qui vient de changer.
+ *
+ * LE FICHIER RESTE LA SOURCE DE VERITE. _byan-output/fd-state.json est ecrit
+ * avant que l'accuse parte ; qui veut l'etat complet appelle byan_fd_status,
+ * dont c'est precisement le metier. On ne perd donc aucune information — on
+ * cesse seulement de la repeter a quelqu'un qui vient de la donner.
+ *
+ * CE QUE L'ACCUSE NE DOIT SURTOUT PAS ETRE. Un etat d'apparence complete.
+ * leantime-fd-sync.js lit l'etat depuis le retour de l'outil, avec un repli
+ * sur le fichier ; sa garde parseFdState exige donc un backlog, pas seulement
+ * une phase. Un accuse est reconnu comme tel et declenche le repli.
+ */
+
+const STATUTS = ['pending', 'building', 'done', 'skipped'];
+
+function compterBacklog(backlog) {
+  const out = { total: 0 };
+  for (const s of STATUTS) out[s] = 0;
+  if (!Array.isArray(backlog)) return out;
+  out.total = backlog.length;
+  for (const item of backlog) {
+    const s = item && typeof item.status === 'string' ? item.status : null;
+    if (s && Object.prototype.hasOwnProperty.call(out, s)) out[s] += 1;
+  }
+  return out;
+}
+
+/**
+ * Construit l'accuse a partir de l'etat qui vient d'etre ecrit.
+ *
+ * @param {object} state l'etat FD complet, tel qu'il vient d'etre persiste
+ * @param {object} [extra] { changed?: string[], from?: string, note?: string }
+ * @returns {object} un accuse compact, jamais une exception
+ */
+export function fdAck(state, extra = {}) {
+  const s = state && typeof state === 'object' && !Array.isArray(state) ? state : {};
+  const e = extra && typeof extra === 'object' ? extra : {};
+
+  const ack = {
+    ok: true,
+    fd_id: s.fd_id ?? null,
+    feature_name: s.feature_name ?? null,
+    phase: typeof s.phase === 'string' ? s.phase : null,
+    backlog: compterBacklog(s.backlog),
+    // Des COMPTES, pas le contenu : c'est le contenu qui pesait.
+    counts: {
+      raw_ideas: Array.isArray(s.raw_ideas) ? s.raw_ideas.length : 0,
+      notes: Array.isArray(s.notes) ? s.notes.length : 0,
+      dispatch_table: Array.isArray(s.dispatch_table) ? s.dispatch_table.length : 0,
+      commits: Array.isArray(s.commits) ? s.commits.length : 0,
+    },
+    // Ou lire l'etat complet quand on en a vraiment besoin. Le dire dans
+    // l'accuse evite d'avoir a s'en souvenir.
+    state_file: '_byan-output/fd-state.json',
+  };
+
+  if (Array.isArray(e.changed) && e.changed.length) ack.changed = e.changed;
+  if (typeof e.from === 'string' && e.from) ack.from = e.from;
+  if (typeof e.note === 'string' && e.note) ack.note = e.note;
+
+  return ack;
+}
+
+export default { fdAck };

package/install/templates/_byan/mcp/byan-mcp-server/lib/leantime-fd-core.js

@@ -47,7 +47,18 @@ export function parseFdState(toolResponse) {
       return null;
     }
   }
-  if (candidate && typeof candidate === 'object' && typeof candidate.phase === 'string') {
+  // UNE PHASE NE SUFFIT PAS A FAIRE UN ETAT. Depuis que les outils d'ecriture
+  // FD rendent un accuse compact au lieu de l'etat entier (lib/fd-ack.js, ne
+  // du constat que ces retours pesaient 38 % de tout ce qui revenait d'un
+  // outil), un objet peut porter une `phase` sans etre un etat. L'accepter
+  // ferait travailler decideActions sur un backlog absent, au lieu de retomber
+  // sur le fichier, qui est la source de verite. On exige donc le backlog.
+  if (
+    candidate &&
+    typeof candidate === 'object' &&
+    typeof candidate.phase === 'string' &&
+    Array.isArray(candidate.backlog)
+  ) {
     return candidate;
   }
   return null;

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

@@ -91,8 +91,16 @@ export const DEEP_PREFIX = 'deep-';
 // check/review/gate/audit/assert/lint; a leaf that runs tests is labelled
 // 'verify-*' in practice.
 const VERIFICATION_KEYWORDS = ['verify', 'validate', 'check', 'assert', 'gate', 'lint', 'audit', 'review'];
-const ANALYSIS_KEYWORDS = ['analy', 'design', 'architect', 'assess', 'evaluate', 'strategy', 'risk', 'nfr', 'recommend', 'judge', 'score', 'coverage', 'synthes'];
-const IMPLEMENTATION_KEYWORDS = ['implement', 'build', 'write', 'generate', 'create', 'dev', 'rgr', 'refactor', 'fix', 'scaffold', 'save', 'optimize', 'aggregate', 'report', 'present', 'plan', 'map', 'select', 'subprocess', 'sub-'];
+// 'concev'/'concept' : le jumeau francais de 'design'. Sans lui, "Concevoir un
+// moteur ... avec detection de cycles" tombait sur 'detect' et repartait en
+// exploration, donc sur le bas de gamme — une tache de conception retrogradee
+// par un mot du milieu de phrase.
+const ANALYSIS_KEYWORDS = ['analy', 'design', 'architect', 'assess', 'evaluate', 'strategy', 'risk', 'nfr', 'recommend', 'judge', 'score', 'coverage', 'synthes', 'concev', 'concept'];
+// Meme raison cote fabrication : "corriger la liste des dependances" contient
+// 'list' et repartait en exploration. La priorite protege-d-abord ne joue que
+// si le vocabulaire protege existe aussi en francais. Les radicaux couvrent
+// les conjugaisons courantes (corrige, correction, redaction...).
+const IMPLEMENTATION_KEYWORDS = ['implement', 'build', 'write', 'generate', 'create', 'dev', 'rgr', 'refactor', 'fix', 'scaffold', 'save', 'optimize', 'aggregate', 'report', 'present', 'plan', 'map', 'select', 'subprocess', 'sub-', 'ecrire', 'redig', 'corrig', 'construi', 'developp', 'ajout', 'modifi'];
 // cartograph/inventaire/recensement... : vocabulaire de cartographie de
 // l'existant (lecture + synthese), francais inclus — cas terrain byan_web ou
 // des feuilles de scan DISCOVERY non reconnues heritaient d'une session Fable 5.
@@ -171,3 +179,107 @@ export function isKnownTierModel(modelId) {
 export function isDowngradeModel(modelId) {
   return modelId === TIER_MODEL.cheap || modelId === TIER_MODEL.balanced;
 }
+
+// =========================================================================
+// Croisement NATURE x COMPLEXITE (surface "dispatch de tache")
+// =========================================================================
+// Tout ce qui precede repond a "quel modele merite cette FEUILLE de workflow",
+// une question sans complexite : le linter lit un script statique, il n'a qu'un
+// libelle. Ce qui suit repond a une question differente : "quel modele merite
+// cette TACHE", quand un score de complexite existe. Meme taxonomie de natures,
+// deux surfaces. La nature seule ne peut pas trancher : elle dit combien de
+// jugement le travail porte, pas s'il est dur. Un hello world et un moteur de
+// resolution de dependances sont tous deux de l'implementation ; les router sur
+// le meme modele est le defaut que ce bloc corrige.
+//
+// L'echelle par complexite n'est PAS redefinie ici : elle vit dans
+// dispatch-router.js (claudeModelForComplexity) et ce module la consomme. Deux
+// echelles finiraient par diverger — exactement le defaut qu'on corrige.
+export { claudeModelForComplexity as modelForComplexity } from './dispatch-router.js';
+import { claudeModelForComplexity, claudeEffortForModel } from './dispatch-router.js';
+
+// Provenance du score de complexite. DECLARED = un appelant l'a juge et fourni.
+// ESTIMATED = personne ne l'a juge, il a ete devine (longueur du prompt chez
+// dispatch()). La distinction porte une decision : la longueur d'un prompt dit
+// long ou court, jamais facile ou difficile ("refactor auth" tient en treize
+// caracteres), donc un score estime n'autorise ni retrogradation ni montee en
+// gamme d'un travail protege.
+export const COMPLEXITY_SOURCES = Object.freeze({ DECLARED: 'declared', ESTIMATED: 'estimated' });
+
+// Seuil du plancher anti-retrogradation (B2). Au-dessus, une implementation est
+// tenue pour complexe : son modele ne peut plus etre un modele de repli. En
+// dessous, l'echelle a le droit de descendre — une tache simple n'a pas besoin
+// du modele le plus cher, et c'est tout l'objet du chantier.
+// 67 est precisement le barreau ou l'echelle elle-meme cesse de descendre
+// (opus) : les deux regles se rejoignent au lieu de se contredire, et le
+// plancher reste un garde-fou si l'echelle bougeait un jour.
+export const PROTECTED_FLOOR_COMPLEXITY = 67;
+
+// applyProtectedFloor(model, complexity) -> le modele apres plancher.
+// Le plancher ne fait qu'une chose : au-dessus du seuil, refuser un modele de
+// repli et rendre null (herite du modele de session). Il ne descend jamais rien
+// et ne bloque pas une montee en gamme.
+export function applyProtectedFloor(model, complexity) {
+  if (!(complexity >= PROTECTED_FLOOR_COMPLEXITY)) return model;
+  return isDowngradeModel(model) ? null : model;
+}
+
+// tierOfModel(model) -> le niveau annonce pour un modele effectivement choisi.
+// Necessaire depuis que le modele ne sort plus de la seule nature : le champ
+// "tier" doit decrire ce qui a ete decide, pas la classe theorique de la nature,
+// sinon un verdict se contredit lui-meme (tier deep + modele haiku). Les modeles
+// de haut de gamme retombent sur deep : deep veut dire "rien n'a ete retrograde".
+export function tierOfModel(model) {
+  if (model === TIER_MODEL.cheap) return TIERS.CHEAP;
+  if (model === TIER_MODEL.balanced) return TIERS.BALANCED;
+  return TIERS.DEEP;
+}
+
+function clampComplexity(complexity) {
+  return Math.min(100, Math.max(0, complexity));
+}
+
+// modelForTask({ nature, complexity, source }) -> le modele a passer (chaine) ou
+// null (herite du modele de session). C'est le croisement des deux axes.
+//
+// La nature decide COMMENT la complexite a le droit de jouer :
+//   verification  : elle ne joue pas. Ligne rouge — un controleur qu'on
+//                   retrograde ne controle plus rien, et on ne le pin pas non
+//                   plus en gamme : il reste sur le modele de session, comme
+//                   dans le script byan-auto-dispatch.
+//   mechanique    : elle ne joue pas non plus. La nature est declaree sans
+//                   jugement (un JSON parse ou ne parse pas) ; sa difficulte
+//                   annoncee ne change pas ce fait.
+//   exploration   : l'echelle joue, plafonnee a sonnet. Un scan enorme merite
+//                   mieux que le bas de gamme, jamais le haut de gamme.
+//   analyse       : l'echelle joue, plancher a sonnet (le linter refuse haiku
+//                   sur une analyse) et montee en gamme permise.
+//   implementation: l'echelle joue en entier, sous le plancher conditionnel.
+export function modelForTask({ nature, complexity, source = COMPLEXITY_SOURCES.ESTIMATED } = {}) {
+  if (nature === LEAF_TYPES.VERIFICATION) return null;
+  if (nature === LEAF_TYPES.MECHANICAL) return TIER_MODEL[TIERS.BALANCED];
+
+  const tierDeLaNature = tierFor(nature);
+  // Sans score exploitable, ou avec un score seulement devine, on s'en tient a
+  // la nature : c'est le comportement d'avant, et il est protecteur.
+  if (!Number.isFinite(complexity) || source !== COMPLEXITY_SOURCES.DECLARED) {
+    return TIER_MODEL[tierDeLaNature];
+  }
+
+  const cx = clampComplexity(complexity);
+  const echelon = claudeModelForComplexity(cx);
+
+  if (nature === LEAF_TYPES.EXPLORATION) {
+    return isUpTierModel(echelon) ? TIER_MODEL[TIERS.BALANCED] : echelon;
+  }
+  if (nature === LEAF_TYPES.ANALYSIS) {
+    return echelon === TIER_MODEL.cheap ? TIER_MODEL[TIERS.BALANCED] : echelon;
+  }
+  return applyProtectedFloor(echelon, cx);
+}
+
+// The effective model includes nature floors/caps and the verification guard.
+// Deriving effort afterwards keeps both knobs on the same rung.
+export function effortForTask(task) {
+  return claudeEffortForModel(modelForTask(task));
+}