create-byan-agent 2.48.0 → 2.50.0

package/install/templates/.claude/hooks/lib/voice-conformance.js

@@ -0,0 +1,97 @@
+'use strict';
+
+// WI-2 core — the reactive net for BYAN voice conformance (soul/tao).
+//
+// The tao is injected as context (inject-tao / voice-anchor) but nothing checks
+// that a reply actually holds the voice : it is prose Claude can drift from. This
+// net scans the finished reply for the OBJECTIVE, low-false-positive voice
+// signals and flags a slip carried to the next turn — the same forward-net
+// mechanics as plain-language / agent-gate. It is NON-BLOCKING by design : the
+// register/timbre of the tao is semantic and cannot be a hard wall without
+// constant false positives (honest ceiling ; deep audit stays byan-mantra-audit).
+//
+// Two objective signals only :
+//   1. emoji in the reply (Mantra IA-23 : zero emoji — hard, unambiguous).
+//   2. vouvoiement (BYAN tutoies always, per tao) — flagged only on a CLUSTER
+//      (>= 2 occurrences) so a single quoted "vous" does not trip it.
+//
+// Pure (no I/O beyond the slip flag). Code spans are stripped before scanning so
+// a quoted `vous` variable or an emoji inside a code sample is not policed.
+
+const fs = require('fs');
+const path = require('path');
+const { stripCode } = require('./plain-language');
+
+// True pictographic emoji (Mantra IA-23). Excludes plain arrows (U+2190-21FF)
+// which BYAN uses legitimately in prose ("->", "→").
+const EMOJI_RE = /[\u{1F000}-\u{1FAFF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{2B00}-\u{2BFF}\u{1F1E6}-\u{1F1FF}\u{FE0F}]/u;
+
+// Second-person-plural address. French-aware boundaries so "nous"/"vousXYZ" and
+// accented neighbours do not false-match.
+const VOUS_RE = /(?<![A-Za-zÀ-ÿ0-9_])(vous|votre|vos|vôtre|vôtres)(?![A-Za-zÀ-ÿ0-9_])/gi;
+
+// scanVoice(text) -> [{ kind, good }]. Empty when the reply holds the voice.
+function scanVoice(text) {
+  const prose = stripCode(text);
+  if (!prose) return [];
+  const hits = [];
+  if (EMOJI_RE.test(prose)) {
+    hits.push({ kind: 'emoji', good: 'zero emoji (Mantra IA-23) — retire-les' });
+  }
+  const vousCount = (prose.match(VOUS_RE) || []).length;
+  if (vousCount >= 2) {
+    hits.push({ kind: 'vouvoiement', good: 'BYAN tutoie toujours (tao) — dis "tu", pas "vous"' });
+  }
+  return hits;
+}
+
+function formatReminder(hits) {
+  if (!Array.isArray(hits) || hits.length === 0) return '';
+  const shown = hits.map((h) => `${h.kind} (${h.good})`).join(' ; ');
+  return [
+    'Rappel voix (tao / soul) : au dernier tour la voix BYAN a glisse ->', `${shown}.`,
+    'Reformule ce tour-ci dans la voix BYAN (tutoiement, zero emoji), sans refaire',
+    'la reponse precedente.',
+  ].join(' ');
+}
+
+// --- slip flag (isolated I/O, same family as the other forward nets) ----------
+
+function slipPath(projectDir) {
+  return path.join(projectDir, '_byan-output', '.voice-slip.json');
+}
+
+function writeSlip(projectDir, hits) {
+  try {
+    const p = slipPath(projectDir);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify({ hits }));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readSlip(projectDir) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(slipPath(projectDir), 'utf8'));
+    return Array.isArray(parsed.hits) ? parsed.hits : null;
+  } catch {
+    return null;
+  }
+}
+
+function clearSlip(projectDir) {
+  try { fs.rmSync(slipPath(projectDir), { force: true }); } catch { /* never block */ }
+}
+
+module.exports = {
+  EMOJI_RE,
+  VOUS_RE,
+  scanVoice,
+  formatReminder,
+  slipPath,
+  writeSlip,
+  readSlip,
+  clearSlip,
+};

package/install/templates/.claude/hooks/strict-scope-guard.js

@@ -57,9 +57,48 @@ function matchesPrefix(rel, prefix) {
   return rel === p || rel.startsWith(p + '/');
 }
 
-// Pure decision : returns { deny, reason }.
-function decideScope({ state, config, toolName, filePath }) {
-  if (!['Write', 'Edit'].includes(toolName)) return { deny: false };
+// WI-6 — the Bash write-redirection leak.
+//
+// The Write/Edit deny is bypassable : `cat > src/x.js`, `echo >> a`, `tee f`,
+// `cmd <<EOF > f` write files through Bash, which the tool-name check missed.
+// bashWriteTargets extracts the file targets of write-redirections from a Bash
+// command so the SAME allowed-paths rule applies. Deliberately conservative to
+// avoid denying legit Bash : it skips fd-dups (`2>&1`, `>&2`), process
+// substitution (`>(...)`), and the /dev/* sinks. It is not a hermetic sandbox
+// (pipes, `python -c open()`, variables escape) — it closes the COMMON reflex
+// leak, honestly bounded (see docs).
+function bashWriteTargets(command) {
+  const cmd = String(command || '');
+  const out = [];
+  // A redirection target only counts when it LOOKS like a file path : it contains
+  // a "/" or a file extension. This is the false-positive kill switch : it drops
+  // comparison / arithmetic / here-string operands (`[ 5 > 3 ]`, `(( a > 2 ))`,
+  // `<<< "a > b"` -> "3", "2", "b") which are numbers or bare words, and drops an
+  // unexpanded variable target (`> $F`) which we cannot resolve — denying it would
+  // be a false positive on a possibly in-scope path. Honest ceiling : a bare
+  // filename with no extension (`> outfile`) or a variable target is NOT caught.
+  const consider = (t) => {
+    if (!t) return;
+    if (t.startsWith('$') || t.startsWith('&') || t.startsWith('-')) return; // variable / fd-dup / flag
+    if (/^\/dev\//.test(t)) return; // /dev sinks
+    const pathShaped = t.includes('/') || /\.[A-Za-z0-9]+$/.test(t);
+    if (pathShaped) out.push(t);
+  };
+  // > , >> , &> , &>> , and fd-prefixed (2>) redirections. The lookahead (?![&(])
+  // drops `>&1` (fd dup) and `>(` (process substitution).
+  const redir = /(?:^|[\s;|&(])\d*(?:>>?|&>>?)\s*(?![&(])("?)([^\s"'`|;&<>()]+)\1/g;
+  let m;
+  while ((m = redir.exec(cmd)) !== null) consider(m[2]);
+  // tee [flags] file...
+  const tee = /\btee\b((?:\s+-\S+)*)\s+("?)([^\s"'`|;&<>()]+)\2/g;
+  while ((m = tee.exec(cmd)) !== null) consider(m[3]);
+  return out;
+}
+
+// Pure decision : returns { deny, reason }. Handles Write/Edit (file_path) and,
+// since WI-6, Bash (write-redirection targets that land INSIDE the repo).
+function decideScope({ state, config, toolName, filePath, command }) {
+  if (!['Write', 'Edit', 'Bash'].includes(toolName)) return { deny: false };
   if (!isEngaged(state)) return { deny: false };
 
   const guard = (config && config.scope_guard) || {};
@@ -69,25 +108,42 @@ function decideScope({ state, config, toolName, filePath }) {
   if (!Array.isArray(allowed) || allowed.length === 0) return { deny: false };
 
   const root = projectRoot();
-  const rel = toRelative(filePath, root);
-  if (!rel) return { deny: false };
-
   const exempt = guard.exempt_globs || [];
-  if (exempt.some((g) => matchesPrefix(rel, g))) return { deny: false };
-
-  if (allowed.some((a) => matchesPrefix(rel, a))) return { deny: false };
-
   const base =
     (config && config.banners && config.banners.scope_deny) ||
     'Strict mode: this write targets a path outside the locked scope.';
-  const reason =
+
+  // Returns the offending rel path, or null when the target is allowed/exempt.
+  const offending = (rawTarget, { repoOnly = false } = {}) => {
+    const rel = toRelative(rawTarget, root);
+    if (!rel) return null;
+    // repoOnly (Bash): a target outside the repo (../, /tmp, absolute elsewhere)
+    // is transient, not a repo change under cover of the locked task -> ignore.
+    if (repoOnly && rel.startsWith('..')) return null;
+    if (exempt.some((g) => matchesPrefix(rel, g))) return null;
+    if (allowed.some((a) => matchesPrefix(rel, a))) return null;
+    return rel;
+  };
+
+  const buildReason = (rel) =>
     `${base}\n` +
     `Target: ${rel}\n` +
     `Locked paths: ${allowed.join(', ')}\n` +
     `Either this file belongs to the scope (re-lock with byan_strict_lock_scope ` +
     `including the corrected paths) or it does not (do not write it).`;
 
-  return { deny: true, reason };
+  if (toolName === 'Write' || toolName === 'Edit') {
+    const bad = offending(filePath);
+    return bad ? { deny: true, reason: buildReason(bad) } : { deny: false };
+  }
+
+  // Bash : deny if any in-repo write-redirection target is out of scope.
+  const targets = bashWriteTargets(command);
+  for (const t of targets) {
+    const bad = offending(t, { repoOnly: true });
+    if (bad) return { deny: true, reason: buildReason(bad) };
+  }
+  return { deny: false };
 }
 
 function allow() {
@@ -106,8 +162,9 @@ if (require.main === module) {
     const toolName = payload.tool_name || payload.toolName || '';
     const input = payload.tool_input || payload.toolInput || {};
     const filePath = input.file_path || '';
+    const command = input.command || '';
 
-    const decision = decideScope({ state, config, toolName, filePath });
+    const decision = decideScope({ state, config, toolName, filePath, command });
     if (!decision.deny) {
       process.stdout.write(JSON.stringify(allow()));
       process.exit(0);
@@ -125,4 +182,4 @@ if (require.main === module) {
   })();
 }
 
-module.exports = { decideScope, toRelative, matchesPrefix };
+module.exports = { decideScope, toRelative, matchesPrefix, bashWriteTargets };

package/install/templates/.claude/hooks/voice-conformance-check.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+'use strict';
+
+// Stop hook — WI-2, the reactive net for BYAN voice conformance (soul/tao).
+//
+// At end of turn it scans the finished reply for the objective voice slips (emoji,
+// vouvoiement cluster) and, on a slip, writes a one-turn flag under _byan-output/.
+// The next-turn voice anchor surfaces it in plain French. It NEVER blocks the turn
+// (the register is semantic — a hard wall would false-positive) : always exits 0.
+//
+// The judgment lives in lib/voice-conformance.js (pure) ; this shell only pulls
+// the reply text from the transcript.
+
+const { extractLastAssistantText } = require('./lib/transcript-read');
+const voice = require('./lib/voice-conformance');
+
+function detect(payload, projectDir) {
+  const text = extractLastAssistantText(payload);
+  const hits = voice.scanVoice(text);
+  if (hits.length) voice.writeSlip(projectDir, hits);
+  return hits;
+}
+
+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(''));
+  });
+}
+
+if (require.main === module) {
+  (async () => {
+    const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    let payload = {};
+    try {
+      const raw = await readStdin();
+      if (raw && raw.trim()) payload = JSON.parse(raw);
+    } catch {
+      payload = {};
+    }
+    try {
+      detect(payload, projectDir);
+    } catch {
+      // never block end-of-turn
+    }
+    process.stdout.write('{}');
+    process.exit(0);
+  })();
+}
+
+module.exports = { detect };

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

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

package/install/templates/.claude/settings.json

@@ -90,6 +90,10 @@
             "type": "command",
             "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/agent-gate-check.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
+          {
+            "type": "command",
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/voice-conformance-check.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
+          },
           {
             "type": "command",
             "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/drain-advisory.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
@@ -112,6 +116,10 @@
           {
             "type": "command",
             "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/strict-scope-guard.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
+          },
+          {
+            "type": "command",
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/codex-delegate-guard.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           }
         ]
       },

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

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

package/install/templates/_byan/mcp/byan-mcp-server/bin/byan-armament-report.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+// WI-7 — the armament observation report (CLI, ESM).
+//
+// Reads the observation ledgers under _byan-output/, reads the CURRENT armed
+// flags from config, and prints per-guard : sample size, would-fire count (the
+// false-positive risk proxy), current armed state, and a calibrated
+// recommendation. It NEVER arms anything — arming is a deliberate config flip the
+// human makes after reading this.
+//
+// Usage : node bin/byan-armament-report.js [--json] [--root <dir>]
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildReport } from '../lib/armament-report.js';
+
+function parseArgs(argv) {
+  const a = { json: false, root: process.env.CLAUDE_PROJECT_DIR || process.cwd() };
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === '--json') a.json = true;
+    else if (argv[i] === '--root') a.root = argv[++i];
+  }
+  return a;
+}
+
+function readLedger(root, name) {
+  try {
+    const p = path.join(root, '_byan-output', name);
+    return fs.readFileSync(p, 'utf8').split('\n').filter(Boolean).map((l) => {
+      try { return JSON.parse(l); } catch { return null; }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// Best-effort read of the current armed flags from config (absent -> false).
+function readArmedFlags(root) {
+  const flags = { autobench: false, punt: false, completeness: false };
+  try {
+    const a = JSON.parse(fs.readFileSync(path.join(root, '.claude', 'hooks', 'lib', 'autobench-config.json'), 'utf8'));
+    flags.autobench = Boolean(a && a.enforcement && a.enforcement.armed);
+  } catch { /* absent -> false */ }
+  try {
+    const d = JSON.parse(fs.readFileSync(path.join(root, '_byan', '_config', 'delivery-default.json'), 'utf8'));
+    flags.punt = Boolean(d && d.puntGuard && d.puntGuard.armed);
+    flags.completeness = Boolean(d && d.completenessGate && d.completenessGate.armed);
+  } catch { /* absent -> false */ }
+  return flags;
+}
+
+function render(report) {
+  const lines = ['BYAN armament report (observe first, arm on evidence) :', ''];
+  const label = { autobench: 'Auto-Benchmark', punt: 'Punt guard', completeness: 'Completeness gate' };
+  for (const key of Object.keys(report)) {
+    const g = report[key];
+    const s = g.summary;
+    lines.push(`- ${label[key] || key} : armed=${g.armed} | observations=${s.total} | would-fire=${s.wouldFire} (${Math.round(s.fireRate * 100)}%)`);
+    lines.push(`    -> ${g.recommend.arm ? 'ARM' : 'HOLD'} : ${g.recommend.reason}`);
+  }
+  lines.push('');
+  lines.push('Note : "would-fire" est un indicateur de risque a relire, pas un compte prouve de faux positifs.');
+  lines.push('Armer reste une decision manuelle (autobench-config.json enforcement.armed, delivery-default.json puntGuard/completenessGate.armed).');
+  return lines.join('\n');
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  const report = buildReport(
+    {
+      benchmark: readLedger(args.root, 'benchmark-ledger.jsonl'),
+      punt: readLedger(args.root, 'punt-ledger.jsonl'),
+      completeness: readLedger(args.root, 'completeness-ledger.jsonl'),
+    },
+    readArmedFlags(args.root)
+  );
+  if (args.json) process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+  else process.stdout.write(render(report) + '\n');
+}
+
+main();
+
+export { readLedger, readArmedFlags, render };

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

@@ -0,0 +1,80 @@
+// WI-7 core — the armament observation report (ESM, matches this package's type).
+//
+// Two BYAN teeth are BUILT but DISARMED by config : the auto-benchmark Stop guard
+// and the punt / completeness guards. They only observe + ledger today. Arming
+// one turns it into a refuse-once, which costs a regeneration on every FALSE
+// positive — the risk the user rejected for a hard wall. So arming must be a
+// measured decision, not a blind flip.
+//
+// This pure core reads the observation ledgers and, per guard, reports : how many
+// entries the guard WOULD have acted on if armed (the false-positive risk proxy),
+// over how large a sample, and a recommendation. It NEVER arms anything — the
+// human flips the config after reading this. Honest limit : the ledger has no
+// ground truth, so "wouldFire" is a risk proxy to eyeball, not a proven
+// false-positive count.
+
+// Per-ledger classifiers : does this entry represent the guard ACTING (a block /
+// refuse-once) if it were armed ?
+export function classifyBenchmark(e) {
+  if (!e || typeof e !== 'object') return 'skip';
+  if (typeof e.event === 'string' && /block|regen|unmarked/i.test(e.event)) return 'wouldFire';
+  // a real choice presented (choice-language + an artifact) without a marker and
+  // not on the never-list is exactly what the armed guard blocks.
+  if (e.choiceLang && e.artifact && !e.marker && !e.neverHit) return 'wouldFire';
+  return 'satisfied';
+}
+
+export function classifyPunt(e) {
+  if (!e || typeof e !== 'object') return 'skip';
+  if (e.punt === true) return 'wouldFire';
+  if (typeof e.event === 'string' && /punt/i.test(e.event)) return 'wouldFire';
+  return 'satisfied';
+}
+
+export function classifyCompleteness(e) {
+  if (!e || typeof e !== 'object') return 'skip';
+  if (Array.isArray(e.missing) && e.missing.length > 0) return 'wouldFire';
+  if (typeof e.event === 'string' && /block|gap|fire/i.test(e.event)) return 'wouldFire';
+  return 'satisfied';
+}
+
+export function summarize(entries, classify) {
+  const s = { total: 0, wouldFire: 0, satisfied: 0, armedSeen: false };
+  for (const e of Array.isArray(entries) ? entries : []) {
+    const c = classify(e);
+    if (c === 'skip') continue;
+    s.total += 1;
+    if (e && e.armed === true) s.armedSeen = true;
+    if (c === 'wouldFire') s.wouldFire += 1;
+    else s.satisfied += 1;
+  }
+  s.fireRate = s.total ? s.wouldFire / s.total : 0;
+  return s;
+}
+
+// recommend — the calibrated arming call. Never arm on a small sample ; arm only
+// on a clean record ; otherwise send the human to review the contexts first.
+export function recommend(summary, { minSample = 20 } = {}) {
+  if (!summary || summary.total < minSample) {
+    return { arm: false, reason: `echantillon trop petit (${summary ? summary.total : 0} < ${minSample}) — continuer d'observer avant de decider` };
+  }
+  if (summary.wouldFire === 0) {
+    return { arm: true, reason: `0 declenchement sur ${summary.total} observations — armement sur (aucun faux positif observe)` };
+  }
+  const pct = Math.round(summary.fireRate * 100);
+  return { arm: false, reason: `${summary.wouldFire}/${summary.total} declenchements (${pct}%) — relire ces contextes avant d'armer (chaque faux positif coute une regeneration)` };
+}
+
+// buildReport — the whole picture. `armedFlags` carries the CURRENT config state
+// (read by the bin) so the report shows observed-vs-armed side by side.
+export function buildReport({ benchmark = [], punt = [], completeness = [] } = {}, armedFlags = {}) {
+  const guards = {
+    autobench: { summary: summarize(benchmark, classifyBenchmark), armed: Boolean(armedFlags.autobench) },
+    punt: { summary: summarize(punt, classifyPunt), armed: Boolean(armedFlags.punt) },
+    completeness: { summary: summarize(completeness, classifyCompleteness), armed: Boolean(armedFlags.completeness) },
+  };
+  for (const k of Object.keys(guards)) {
+    guards[k].recommend = recommend(guards[k].summary);
+  }
+  return guards;
+}

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

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