create-byan-agent 2.48.0 → 2.50.0

package/CHANGELOG.md

@@ -9,6 +9,56 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.50.0] - 2026-07-17
+
+### Added — BYAN souverainete (les concepts BYAN pilotent Claude, ne se font plus doubler)
+- **WI-1 dent delegation Codex** : hook PreToolUse `codex-delegate-guard.js` (+ coeur pur `lib/codex-delegate-gate.js`) qui refuse-une-fois le premier Write/Edit de code delegable quand la voie Codex est armee (option + Codex linke) et qu'aucune delegation n'a eu lieu ce tour. Speed-bump, pas un mur : escape `.byan-codex-autodelegate/off`, marque `// BYAN-DELEGATE: reviewed`, fenetre de grace. Corrige la racine de l'incident (Claude codait lui-meme malgre la directive).
+- **WI-2 filet de conformite de voix** : hook Stop `voice-conformance-check.js` (+ `lib/voice-conformance.js`) qui repere les signaux objectifs de derive (emoji, vouvoiement en grappe) et pose un drapeau relaye au tour suivant. Non bloquant (le registre reste semantique).
+- **WI-3 filet dispatch runtime** : drapeau quand un tour ecrit du code sans avoir consulte `byan_dispatch`, hors FD.
+- **WI-4 garde de porte d'entree renforce** : le signal visuel party-mode (`TaskCreate`/`TaskUpdate`) tient desormais la posture d'entree — plus de faux drapeau sur un tour party-mode.
+- **WI-7 rapport d'armement** : `bin/byan-armament-report.js` (+ `lib/armament-report.js`) lit les registres autobench/punt/completeness et reporte le taux de declenchement (indicateur de risque de faux positif) avant toute decision d'armement. Verdict mesure : les 3 gardes restent DESARMEES (punt 42%, autobench 1%, completeness echantillon trop petit).
+
+### Changed
+- **WI-6 fuite Bash du strict-scope-guard** : `decideScope` couvre desormais les redirections d'ecriture Bash (`>`, `>>`, `tee`, heredoc) hors `allowedPaths`. Parseur resserre (cible en forme de chemin uniquement) pour eviter les faux positifs sur les operateurs de comparaison/arithmetique et les variables non resolues.
+- **WI-5 fact-check-absolutes elargi** : plus d'absolus/superlatifs/best-practice/certitudes couverts (alignes sur `.claude/rules/fact-check.md`) ; `optimal` ecarte (trop courant) et strip d'exemples resserre a une puce (une phrase de prose commencant par un absolu reste policee). Le plafond des mantras semantiques (IA-16, #37...) est assume : doctrine + `byan-mantra-audit`, pas de fausse dent regex.
+
+### Docs
+- `docs/byan-sovereignty-chantier.md` : le chantier complet (constat, patron des 4 dents, plafond honnete, work items, risques) adosse a l'audit `byan-sovereignty-audit`.
+
+### Tests
+- +9 tests MCP (armament report + parite shipping anti-derive) ; +47 tests jest (dents + filets + fact-check + strict-scope Bash). jest 2699/0, MCP 855/0.
+
+## [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.50.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/agent-gate-check.js

@@ -20,12 +20,24 @@ const gate = require('./lib/agent-gate');
 function detect(payload, projectDir) {
   const text = extractLastAssistantText(payload);
   const messages = extractRecentMessages(payload, 8) || [];
+  const wroteFiles = gate.hasWriteActivity(messages);
+  const fdActive = gate.fdIsActive(projectDir);
   const assessment = gate.assessTurn({
-    wroteFiles: gate.hasWriteActivity(messages),
+    wroteFiles,
     proposedAgent: gate.hasProposalMarker(text),
-    fdActive: gate.fdIsActive(projectDir),
+    taskVisualSeen: gate.hasTaskActivity(messages), // WI-4: a live task list holds the entry posture
+    fdActive,
   });
   if (assessment.slip) gate.writeSlip(projectDir, assessment.reason);
+  // WI-3: dispatch net, its own slip. Same signals, different question (was the
+  // runtime routeur consulted?).
+  const dispatch = gate.assessDispatch({
+    wroteFiles,
+    dispatchConsulted: gate.hasDispatchActivity(messages),
+    fdActive,
+  });
+  if (dispatch.slip) gate.writeDispatchSlip(projectDir, dispatch.reason);
+  assessment.dispatch = dispatch; // backward-compatible: .slip stays primary
   return assessment;
 }
 

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/codex-delegate-guard.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+'use strict';
+
+// PreToolUse hook — WI-1, the DENT for the armed Codex-delegation lane.
+//
+// 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).
+//
+// 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.
+
+const fs = require('fs');
+const path = require('path');
+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 ROOT = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const GRACE_MS = 120000;
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', () => resolve(''));
+  });
+}
+
+function allow() {
+  return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow' } };
+}
+
+function deny(reason) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason: reason,
+    },
+  };
+}
+
+function sidecarPath(root) {
+  return path.join(root, '.byan-codex-delegate', 'last-deny.json');
+}
+
+function readPriorDeny(root) {
+  try {
+    const p = JSON.parse(fs.readFileSync(sidecarPath(root), 'utf8'));
+    return p && typeof p === 'object' ? p : null;
+  } catch (_e) {
+    return null;
+  }
+}
+
+function writePriorDeny(root, entry) {
+  try {
+    fs.mkdirSync(path.dirname(sidecarPath(root)), { recursive: true });
+    fs.writeFileSync(sidecarPath(root), JSON.stringify(entry));
+  } catch (_e) {
+    // best-effort : losing the deny memory only costs one extra deny, never a trap
+  }
+}
+
+// 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 '';
+  for (let i = msgs.length - 1; i >= 0; i--) {
+    if (msgs[i] && msgs[i].role === 'user') return contentToText(msgs[i].content);
+  }
+  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() } = {}) {
+  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);
+
+  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 delegationSeen = gate.delegationSeenThisTurn(extractRecentMessages(payload, 12) || []);
+  const turnHash = gate.hashTurn(filePath, content);
+
+  const decision = gate.decideDelegateGate({
+    armed,
+    delegable,
+    delegationSeen,
+    escaped,
+    reviewedMarker,
+    priorDeny: readPriorDeny(root),
+    turnHash,
+    now,
+    graceMs: GRACE_MS,
+  });
+
+  if (decision.decision === 'deny') {
+    writePriorDeny(root, { hash: turnHash, ts: now });
+    return deny(decision.reason);
+  }
+  return allow();
+}
+
+if (require.main === module) {
+  (async () => {
+    let out;
+    try {
+      const payload = JSON.parse((await readStdin()) || '{}');
+      out = runGuard(payload);
+    } catch (_e) {
+      out = allow();
+    }
+    process.stdout.write(JSON.stringify(out));
+    process.exit(0);
+  })();
+}
+
+module.exports = { runGuard, sidecarPath, readPriorDeny, writePriorDeny, lastUserText };

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

@@ -28,6 +28,7 @@ const path = require('path');
 const { buildTaoContext, turnCounterPath } = require('./inject-tao');
 const pl = require('./lib/plain-language');
 const gate = require('./lib/agent-gate');
+const voice = require('./lib/voice-conformance');
 
 const ANCHOR = [
   'Voix BYAN (rappel par tour ; tao complet chargé au démarrage de session) :',
@@ -96,6 +97,20 @@ function withGateReminder(baseContext, slip) {
   return reminder ? `${baseContext}\n${reminder}` : baseContext;
 }
 
+// Append the dispatch reminder (WI-3) when the previous turn wrote code without
+// consulting byan_dispatch. Pure; fs read + clear stays in require.main.
+function withDispatchReminder(baseContext, slip) {
+  const reminder = gate.formatDispatchReminder(slip);
+  return reminder ? `${baseContext}\n${reminder}` : baseContext;
+}
+
+// Append the voice-conformance reminder (WI-2) when the previous turn drifted from
+// the BYAN voice (emoji / vouvoiement). Pure; fs read + clear stays in require.main.
+function withVoiceReminder(baseContext, hits) {
+  const reminder = voice.formatReminder(hits);
+  return reminder ? `${baseContext}\n${reminder}` : baseContext;
+}
+
 if (require.main === module) {
   const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
   const every = refreshEvery();
@@ -110,8 +125,16 @@ if (require.main === module) {
   // Forward net #2 (F4): agent entry-gate slip. Read + clear one-shot.
   const gateSlip = gate.readSlip(projectDir);
   if (gateSlip) gate.clearSlip(projectDir);
+  // Forward net #3 (WI-3): dispatch-runtime slip. Read + clear one-shot.
+  const dispatchSlip = gate.readDispatchSlip(projectDir);
+  if (dispatchSlip) gate.clearDispatchSlip(projectDir);
+  // Forward net #4 (WI-2): voice-conformance slip. Read + clear one-shot.
+  const voiceHits = voice.readSlip(projectDir);
+  if (voiceHits && voiceHits.length) voice.clearSlip(projectDir);
   let ctx = withSlipReminder(additionalContext, slipHits);
   ctx = withGateReminder(ctx, gateSlip);
+  ctx = withDispatchReminder(ctx, dispatchSlip);
+  ctx = withVoiceReminder(ctx, voiceHits);
   process.stdout.write(
     JSON.stringify({
       hookSpecificOutput: {
@@ -131,5 +154,7 @@ module.exports = {
   decideAnchor,
   withSlipReminder,
   withGateReminder,
+  withDispatchReminder,
+  withVoiceReminder,
   DEFAULT_REFRESH_EVERY,
 };

package/install/templates/.claude/hooks/lib/agent-gate.js

@@ -32,6 +32,33 @@ function hasProposalMarker(text) {
   return PROPOSAL_MARKERS.some((m) => t.includes(m));
 }
 
+// hasToolActivity(messages, predicate) — true if any assistant tool_use block in
+// the recent messages matches the predicate(block). The shared scan used by the
+// write / task-visual / dispatch detectors.
+function hasToolActivity(messages, predicate) {
+  if (!Array.isArray(messages)) return false;
+  for (const m of messages) {
+    if (!m || m.role !== 'assistant' || !Array.isArray(m.content)) continue;
+    for (const block of m.content) {
+      if (block && block.type === 'tool_use' && predicate(block)) return true;
+    }
+  }
+  return false;
+}
+
+// WI-4 — the party-mode live visual signal : did the turn create a native task
+// (TaskCreate) ? A task list IS the visual the entry chain promises, so its
+// presence means the porte d'entree posture held even without a text proposal.
+function hasTaskActivity(messages) {
+  return hasToolActivity(messages, (b) => b.name === 'TaskCreate' || b.name === 'TaskUpdate');
+}
+
+// WI-3 — the dispatch-consulted signal : was the routeur (byan_dispatch) called
+// this turn ? Matches the MCP tool name in any namespaced form.
+function hasDispatchActivity(messages) {
+  return hasToolActivity(messages, (b) => /byan_dispatch/.test(String(b.name || '')));
+}
+
 // hasWriteActivity(messages) — true if any recent assistant message carried a
 // tool_use block that writes to the repo. `messages` is an array of
 // { role, content } where content is a string or a block array.
@@ -47,14 +74,28 @@ function hasWriteActivity(messages) {
 }
 
 // assessTurn — the decision. A slip is a task done directly (files written) with
-// no agent proposal AND no active FD cycle. When an FD is engaged, the gate is
-// already in play (DISPATCH is part of it), so it is never a slip.
-function assessTurn({ wroteFiles = false, proposedAgent = false, fdActive = false } = {}) {
-  const slip = Boolean(wroteFiles && !proposedAgent && !fdActive);
+// no agent proposal, NO party-mode task visual (WI-4), AND no active FD cycle.
+// When an FD is engaged, the gate is already in play (DISPATCH is part of it), so
+// it is never a slip ; likewise a live task list is proof the entry posture held.
+function assessTurn({ wroteFiles = false, proposedAgent = false, taskVisualSeen = false, fdActive = false } = {}) {
+  const slip = Boolean(wroteFiles && !proposedAgent && !taskVisualSeen && !fdActive);
   return {
     slip,
     reason: slip
-      ? 'files written directly without an agent proposal and no active FD cycle'
+      ? 'files written directly without an agent proposal, no task visual, and no active FD cycle'
+      : 'ok',
+  };
+}
+
+// WI-3 — dispatch net. A slip is code written this turn without the runtime
+// routeur (byan_dispatch) ever consulted, outside an FD cycle. Non-blocking : the
+// engine choice is a decision, not a binary invariant, so this only flags.
+function assessDispatch({ wroteFiles = false, dispatchConsulted = false, fdActive = false } = {}) {
+  const slip = Boolean(wroteFiles && !dispatchConsulted && !fdActive);
+  return {
+    slip,
+    reason: slip
+      ? 'code written without consulting byan_dispatch (runtime routing) and no active FD cycle'
       : 'ok',
   };
 }
@@ -100,6 +141,46 @@ function formatReminder(slip) {
   ].join(' ');
 }
 
+// --- dispatch slip (WI-3, its own sidecar, same forward-net mechanics) --------
+
+function dispatchSlipPath(projectDir) {
+  return path.join(projectDir, '_byan-output', '.dispatch-slip.json');
+}
+
+function writeDispatchSlip(projectDir, detail) {
+  try {
+    const p = dispatchSlipPath(projectDir);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify({ detail: String(detail || '') }));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readDispatchSlip(projectDir) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(dispatchSlipPath(projectDir), 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function clearDispatchSlip(projectDir) {
+  try { fs.rmSync(dispatchSlipPath(projectDir), { force: true }); } catch { /* never block */ }
+}
+
+function formatDispatchReminder(slip) {
+  if (!slip) return '';
+  return [
+    'Rappel dispatch runtime (BYAN) : au dernier tour du code a ete ecrit sans',
+    'consulter byan_dispatch (le routeur moteur/modele/effort). La chaine d\'entree',
+    'route avant d\'executer : passe par byan_dispatch pour choisir Codex ou Claude,',
+    'le modele et l\'effort. Applique-le ce tour-ci.',
+  ].join(' ');
+}
+
 // fdIsActive(projectDir) — reads _byan-output/fd-state.json ; active means a live
 // phase (not COMPLETED / ABORTED / absent). Read-only, best-effort.
 function fdIsActive(projectDir) {
@@ -117,11 +198,20 @@ module.exports = {
   WRITE_TOOLS,
   hasProposalMarker,
   hasWriteActivity,
+  hasToolActivity,
+  hasTaskActivity,
+  hasDispatchActivity,
   assessTurn,
+  assessDispatch,
   slipPath,
   writeSlip,
   readSlip,
   clearSlip,
   formatReminder,
+  dispatchSlipPath,
+  writeDispatchSlip,
+  readDispatchSlip,
+  clearDispatchSlip,
+  formatDispatchReminder,
   fdIsActive,
 };

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/hooks/lib/fact-check-core.js

@@ -8,7 +8,14 @@
 
 'use strict';
 
+// WI-5 — the absolute-claim patterns. Kept HIGH-SIGNAL on purpose : this gate
+// hard-blocks a doc write, so a false positive costs the user a block. Every
+// entry is either a plain absolute, a comparative superlative, an unsourced
+// best-practice claim, or a certainty phrase — the exact trigger families named
+// in .claude/rules/fact-check.md. Noisy bare words ("mieux", "the best",
+// "impossible", "bien sur") are deliberately excluded.
 const ABSOLUTES = [
+  // plain absolutes
   /\btoujours\b/i,
   /\bjamais\b/i,
   /\bforc[eé]ment\b/i,
@@ -17,10 +24,31 @@ const ABSOLUTES = [
   /\bnever\b/i,
   /\bclearly\b/i,
   /\bundoubtedly\b/i,
+  /\b[ée]videmment\b/i,
+  /\bcertainly\b/i,
+  /\bwithout a doubt\b/i,
+  /\bsans aucun doute\b/i,
+  /\bguaranteed\b/i,
+  // comparative superlatives (a claim, not phrasing)
   /\bfaster than\b/i,
   /\bbetter than\b/i,
   /\bplus rapide que\b/i,
   /\bmeilleur que\b/i,
+  /\bthe fastest\b/i,
+  /\ble plus rapide\b/i,
+  /\bsuperior to\b/i,
+  // ("optimal" alone was dropped in WI-5 review : too common in legit doc prose
+  //  ("the optimal layout") to hard-block a doc write without a false positive.)
+  // unsourced best-practice / authority claims
+  /\bbest practice\b/i,
+  /\bbonne pratique\b/i,
+  /\bindustry standard\b/i,
+  /\bstandard de l['’]industrie\b/i,
+  // certainty framing
+  /\bil est clair que\b/i,
+  /\bit is well[- ]known\b/i,
+  /\bwell[- ]known that\b/i,
+  /\bprouv[eé] que\b/i,
 ];
 
 const SOURCE_MARKERS = [
@@ -37,14 +65,18 @@ const SOURCE_MARKERS = [
 //   - fenced code blocks ``` ... ```
 //   - inline backticks `...`
 //   - block quotes (lines starting with >)
-//   - list-of-pattern lines (e.g. "- toujours")
+//   - BULLET list-example lines (e.g. "- toujours") — a doc listing the trigger
+//     words as examples, not asserting them. WI-5 review fix : this REQUIRES a
+//     bullet marker (- or *), so a prose sentence merely STARTING with an
+//     absolute ("Never mutate state directly.") is NOT stripped and stays policed
+//     (the old `^[\s-]*` matched any leading whitespace -> a false negative).
 function stripNonClaimZones(text) {
   if (!text) return '';
   return text
     .replace(/```[\s\S]*?```/g, '')
     .replace(/`[^`\n]+`/g, '')
     .replace(/^> .*$/gm, '')
-    .replace(/^[\s-]*['"]?\b(toujours|jamais|forc[eé]ment|obviously|always|never|clearly|undoubtedly)\b['"]?/gim, '');
+    .replace(/^\s*[-*]\s+['"]?\b(toujours|jamais|forc[eé]ment|obviously|always|never|clearly|undoubtedly|[ée]videmment|certainly|guaranteed)\b['"]?/gim, '');
 }
 
 // Return the first unsourced absolute (with surrounding context) or null when