create-byan-agent 2.35.0 → 2.39.0

package/install/templates/.claude/hooks/lib/delivery-contract.js

@@ -0,0 +1,143 @@
+// Pure helpers for the BYAN delivery-default contract (F1).
+//
+// The user asked for something complete. This contract makes prod-grade +
+// maximal scope the DEFAULT the agent assumes every turn, instead of quietly
+// drifting toward an MVP / a short deliverable / a "split so the heavy part
+// does not block". It is the proactive twin of strict mode: strict locks a
+// scope on demand; this anchor sets the BASELINE posture before a scope is
+// even named.
+//
+// F1 ships LIVE (unlike the two blockers F2/F3): it is pure injected context,
+// it blocks nothing, so a false positive costs at most a few tokens — never a
+// trapped turn or a blocked commit. The only escape is an explicit opt-out word
+// the user types THIS message (mvp, quick, brouillon, ...), read from
+// _byan/_config/delivery-default.json so the wordlist is one source of truth.
+//
+// Every function here is pure (no clock, no fs beyond the one config read in
+// loadConfig) so the decision is unit-testable without a hook harness.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Fallback wordlist used only if the config file is missing/unreadable. Keeping
+// it here means the anchor still has a closed opt-out set on a broken install,
+// rather than treating every message as opt-out (fail-safe toward PROD).
+const DEFAULT_OPT_OUT_WORDS = [
+  'mvp',
+  'quick',
+  'brouillon',
+  'jette',
+  'prototype',
+  'vite fait',
+  'pas besoin que ce soit parfait',
+  'poc',
+  'draft',
+];
+
+function configPath(projectRoot) {
+  const root = projectRoot || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  return path.join(root, '_byan', '_config', 'delivery-default.json');
+}
+
+function loadConfig(projectRoot) {
+  try {
+    const p = configPath(projectRoot);
+    if (fs.existsSync(p)) {
+      const cfg = JSON.parse(fs.readFileSync(p, 'utf8'));
+      if (cfg && typeof cfg === 'object') return cfg;
+    }
+  } catch {
+    // Fall through to defaults — a broken config must not silence the anchor.
+  }
+  return {};
+}
+
+function optOutWords(config) {
+  const words = config && Array.isArray(config.optOutWords) ? config.optOutWords : null;
+  return words && words.length ? words : DEFAULT_OPT_OUT_WORDS;
+}
+
+// The full delivery contract. PROD + MAXIMAL + the AI-2026 cost yardstick +
+// the explicit ban on proposing an MVP/short-deliverable/dont-block-the-heavy
+// split. Kept as one builder so the hook and the tests render identical text.
+function buildAnchor() {
+  return [
+    'CONTRAT DE LIVRAISON (defaut): grade=PROD. scope=MAXIMAL -- livre le maximum',
+    'coherent, INTERDIT de proposer un MVP/livrable-court/decoupage-pour-ne-pas-bloquer-le-lourd',
+    'sauf si l\'utilisateur a tape un mot opt-out CE message. Etalon de cout=AI-2026:',
+    'estime en temps-agent (x10), jamais en temps-humain-a-la-main. Tu es un fou',
+    'd\'optimisation: maximum a chaque demande, pas minimum.',
+  ].join(' ');
+}
+
+// Opt-out detection is BIASED TOWARD PROD. A false opt-out (silencing the prod
+// anchor when the user did not ask to) is the one failure that matters, so when
+// in doubt we stay PROD. A single opt-out word counts only when it reads as a
+// directive for THIS task -- the message is short enough to be a directive, OR
+// a "go-cheap" cue sits just before the word -- and it is dropped when negated
+// ("pas de mvp"). A word merely MENTIONED (a long meta message about MVPs, a
+// system notification, an "anti-mvp" discussion) leaves the anchor armed.
+// Curated multi-word phrases ("vite fait", "pas besoin que ce soit parfait")
+// are unambiguous and match as-is.
+const OPT_OUT_NEGATORS = new Set(['pas', 'sans', 'aucun', 'aucune', 'ni', 'no', 'not', 'non']);
+const OPT_OUT_CUES = new Set([
+  'juste', 'just', 'seulement', 'only', 'mode', 'reste', 'simplement',
+  'rapidement', 'vite', 'fais', 'make', 'leave', 'give', 'garde',
+]);
+const OPT_OUT_SHORT_WORDS = 30; // a message this short reads as a directive, not meta
+const OPT_OUT_WINDOW = 3; // tokens before the word inspected for a negator / cue
+
+function tokenizeWords(s) {
+  return s.toLowerCase().match(/[a-z0-9']+/g) || [];
+}
+
+function parseOptOut(userMsg, config) {
+  if (!userMsg || typeof userMsg !== 'string') return false;
+  const lower = userMsg.toLowerCase();
+  const words = optOutWords(config)
+    .map((w) => String(w).toLowerCase().trim())
+    .filter(Boolean);
+
+  // 1) Curated multi-word phrases: unambiguous opt-out intent, substring match.
+  if (words.some((w) => w.includes(' ') && lower.includes(w))) return true;
+
+  // 2) Single words: honoured only in a directive context, dropped when negated.
+  const singles = new Set(words.filter((w) => /^[a-z]+$/.test(w)));
+  if (singles.size === 0) return false;
+  const tokens = tokenizeWords(userMsg);
+  const directiveShort = tokens.length <= OPT_OUT_SHORT_WORDS;
+  for (let i = 0; i < tokens.length; i += 1) {
+    if (!singles.has(tokens[i])) continue;
+    const before = tokens.slice(Math.max(0, i - OPT_OUT_WINDOW), i);
+    if (before.some((t) => OPT_OUT_NEGATORS.has(t))) continue; // "pas de mvp" -> stays PROD
+    if (directiveShort || before.some((t) => OPT_OUT_CUES.has(t))) return true;
+  }
+  return false;
+}
+
+// The per-turn decision. With an opt-out word present this turn, emit a single
+// line authorizing descope; otherwise emit the full anchor. Pure: the caller
+// supplies the message and (optionally) the loaded config.
+function decideContext({ userMsg, config } = {}) {
+  const cfg = config || {};
+  const optOut = parseOptOut(userMsg, cfg);
+  if (optOut) {
+    return {
+      optOut: true,
+      text: 'CONTRAT DE LIVRAISON: OPT-OUT detecte ce message -- descope autorise (grade/scope libres pour cette demande).',
+    };
+  }
+  return { optOut: false, text: buildAnchor() };
+}
+
+module.exports = {
+  DEFAULT_OPT_OUT_WORDS,
+  configPath,
+  loadConfig,
+  optOutWords,
+  buildAnchor,
+  parseOptOut,
+  decideContext,
+};

package/install/templates/.claude/hooks/lib/punt-detect.js

@@ -0,0 +1,143 @@
+// Pure detector for the BYAN punt-guard (F3).
+//
+// A "punt" is the laziness pattern the user fights: the agent ends its turn by
+// telling the human to run a command and paste the output back, when the agent
+// could have run it itself this turn. The signal is a CO-OCCURRENCE in the
+// finished turn:
+//   1. an imperative addressed to the user ("lance", "execute", "colle la
+//      sortie", "run this", "paste", "donne-moi le ssh"), AND
+//   2. a runnable command (a backticked command, or a `node `/`npm `/`git `/
+//      `which `/`curl localhost` invocation), AND
+//   3. NO Bash tool-call for that command this turn (the agent did not actually
+//      run it — it handed it off).
+//
+// Carve-out (creds): `git push` and `npm publish` need credentials the server
+// running Claude Code does not have. Asking the user to run THOSE is legitimate,
+// not a punt — documented in MEMORY (server cannot push). So a command whose
+// runnable token is a push/publish is never flagged.
+//
+// This module is pure decide() — no fs, no stdin — so it is exhaustively
+// unit-testable. The hook wires it to the transcript and the arm flag.
+
+'use strict';
+
+// Imperatives addressed to the user that, paired with a runnable command, mean
+// "you run it". FR + EN. Matched case-insensitively as loose phrases.
+const PUNT_IMPERATIVES = [
+  'lance',
+  'execute',
+  'exécute',
+  'colle la sortie',
+  'colle le resultat',
+  'colle le résultat',
+  'run this',
+  'run it',
+  'paste',
+  'donne-moi le ssh',
+  'donne moi le ssh',
+  'peux-tu lancer',
+  'peux tu lancer',
+  'lance la commande',
+];
+
+// Commands that need creds the server lacks. Asking the user to run these is
+// legitimate (not a punt). Order matters only for reporting the matched token.
+const CREDS_CARVEOUT = ['git push', 'npm publish'];
+
+// Loose runnable-command detectors. A backticked span, or a bare invocation of
+// a common runner at a word boundary. `curl localhost` is included because the
+// dev API runs on localhost and the agent can hit it itself.
+const RUNNABLE_PATTERNS = [
+  /`([^`]+)`/g, // any backticked span
+  /\bnode\s+\S+/gi,
+  /\bnpm\s+\S+/gi,
+  /\bgit\s+\S+/gi,
+  /\bwhich\s+\S+/gi,
+  /\bcurl\s+localhost\S*/gi,
+];
+
+function hasImperativeToUser(text) {
+  if (!text) return false;
+  const lower = text.toLowerCase();
+  return PUNT_IMPERATIVES.some((p) => lower.includes(p));
+}
+
+// Returns the first runnable command found in the text, or null. Backticked
+// spans win (they are the explicit "here is the command" form); else the first
+// bare invocation. The returned string is the matched command text.
+function findRunnableCommand(text) {
+  if (!text) return null;
+  for (const re of RUNNABLE_PATTERNS) {
+    re.lastIndex = 0;
+    const m = re.exec(text);
+    if (m) {
+      // Backtick pattern captures group 1 (the inner command); the bare-runner
+      // patterns have no capture group, so use the full match.
+      return (m[1] !== undefined ? m[1] : m[0]).trim();
+    }
+  }
+  return null;
+}
+
+// True when the command is a creds-gated push/publish (legitimate to delegate).
+function isCredsCarveOut(cmd) {
+  if (!cmd) return false;
+  const lower = cmd.toLowerCase();
+  return CREDS_CARVEOUT.some((c) => lower.includes(c));
+}
+
+// True when a Bash tool-call this turn actually ran (something matching) the
+// command. We match on the meaningful head token of the command (e.g. "npm
+// test" -> we require the Bash command to include "npm test"), so a Bash call
+// that ran a DIFFERENT command does not falsely clear the punt. toolCalls is an
+// array of { name, command } where command is the Bash tool's command string.
+function bashRanCommand(toolCalls, cmd) {
+  if (!Array.isArray(toolCalls) || !cmd) return false;
+  // Compare on a normalized, whitespace-collapsed head so minor formatting
+  // (extra spaces, trailing flags in the prose) does not break the match.
+  const needle = cmd.toLowerCase().replace(/\s+/g, ' ').trim();
+  const headTokens = needle.split(' ').slice(0, 2).join(' '); // e.g. "npm test"
+  return toolCalls.some((tc) => {
+    if (!tc || typeof tc.name !== 'string') return false;
+    if (!/bash/i.test(tc.name)) return false;
+    const ran = String(tc.command || '').toLowerCase().replace(/\s+/g, ' ').trim();
+    if (!ran) return false;
+    return ran.includes(needle) || (headTokens.length > 0 && ran.includes(headTokens));
+  });
+}
+
+// Pure decision. Returns { punt, reason, cmd }.
+//   punt  : true IFF imperative-to-user + runnable command + NOT a creds
+//           carve-out + NO Bash tool-call ran that command this turn.
+//   reason: a short human-readable explanation (or why it is not a punt).
+//   cmd   : the runnable command detected (or null).
+function decide({ lastAssistantText, toolCallsThisTurn } = {}) {
+  const text = lastAssistantText || '';
+  const imperative = hasImperativeToUser(text);
+  const cmd = findRunnableCommand(text);
+
+  if (!imperative || !cmd) {
+    return { punt: false, reason: 'no imperative-to-user + runnable command co-occurrence', cmd: cmd || null };
+  }
+  if (isCredsCarveOut(cmd)) {
+    return { punt: false, reason: `creds carve-out: "${cmd}" needs credentials the server lacks`, cmd };
+  }
+  if (bashRanCommand(toolCallsThisTurn, cmd)) {
+    return { punt: false, reason: `agent ran the command via Bash this turn: "${cmd}"`, cmd };
+  }
+  return {
+    punt: true,
+    reason: `punt detected: asked the user to run "${cmd}" without running it via Bash this turn`,
+    cmd,
+  };
+}
+
+module.exports = {
+  PUNT_IMPERATIVES,
+  CREDS_CARVEOUT,
+  hasImperativeToUser,
+  findRunnableCommand,
+  isCredsCarveOut,
+  bashRanCommand,
+  decide,
+};

package/install/templates/.claude/hooks/lib/strict-config.json

@@ -3,6 +3,20 @@
   "version": 1,
   "min_passes": 3,
   "last_verdict_must_be": "ok",
+  "self_verify_checklist": [
+    {
+      "theme": "tests/coverage",
+      "check": "Every changed branch has a test, the pre-existing suite still passes with no regression, and any new behaviour has a test that would fail without the change?"
+    },
+    {
+      "theme": "doc-follows-code",
+      "check": "Did a public-surface or contract change leave a doc behind that must move with it — CHANGELOG, README, a rule @-reference, a manifest, a template mirror?"
+    },
+    {
+      "theme": "scope-discovery",
+      "check": "Anything discovered mid-build outside the locked scope (a legacy tree, an extra decision, an adjacent bug) surfaced to the user rather than silently absorbed or cut?"
+    }
+  ],
   "min_score": 95,
   "auto_keywords": [
     "prod",

package/install/templates/.claude/hooks/punt-guard.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+/**
+ * Stop hook — BYAN punt-guard (F3).
+ *
+ * Goal : catch the laziness pattern where the agent ends its turn by telling the
+ * user to run a command and paste the output back, when the agent could have run
+ * it itself (a Bash tool-call) this turn. The pure detection lives in
+ * lib/punt-detect.js; this hook wires it to the real Stop payload and the arm
+ * flag.
+ *
+ * Ships DISARMED (puntGuard.armed=false in _byan/_config/delivery-default.json),
+ * same posture as the autobench Stop guard. Arming a Stop blocker without first
+ * measuring false positives breaks the flow. So by default the hook only
+ * OBSERVES: it appends one line to _byan-output/punt-ledger.jsonl
+ * (observed-disarmed / observed-disarmed-punt) and exits 0. Only when armed does
+ * it block (exit 2) on a detected punt.
+ *
+ * Carve-out (in punt-detect): git push / npm publish are never flagged — the
+ * server has no creds, so delegating those to the user is legitimate.
+ *
+ * Non-blocking on any IO/parse error : the hook never traps a turn it cannot read.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { decide } = require('./lib/punt-detect');
+const { loadConfig } = require('./lib/delivery-contract');
+// transcript-read is the canonical Stop-payload reader (text + raw content); it
+// does NOT carry stdin helpers, so readStdin/parseJson come from strict-runtime
+// like the other Stop/prompt hooks.
+const { extractLastAssistantText, extractLastAssistantContent } = require('./lib/transcript-read');
+const { readStdin, parseJson } = require('./lib/strict-runtime');
+
+function projectRoot() {
+  return process.env.CLAUDE_PROJECT_DIR || process.cwd();
+}
+
+function isArmed(config) {
+  const pg = config && config.puntGuard;
+  return !!(pg && pg.armed === true);
+}
+
+// Pull the Bash tool-calls out of the finished assistant turn's RAW content.
+// transcript-read gives the block array; a Bash tool_use is
+// { type:'tool_use', name:'Bash', input:{ command } }. Returns [{ name, command }].
+function bashToolCalls(content) {
+  if (!Array.isArray(content)) return [];
+  const out = [];
+  for (const b of content) {
+    if (b && b.type === 'tool_use' && typeof b.name === 'string') {
+      const command = b.input && typeof b.input.command === 'string' ? b.input.command : '';
+      out.push({ name: b.name, command });
+    }
+  }
+  return out;
+}
+
+function ledgerPath() {
+  return path.join(projectRoot(), '_byan-output', 'punt-ledger.jsonl');
+}
+
+function appendLedger(entry) {
+  try {
+    const p = ledgerPath();
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.appendFileSync(p, JSON.stringify(entry) + '\n');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+if (require.main === module) {
+  (async () => {
+    // Wrap everything : the hook must NEVER trap a turn it cannot read.
+    try {
+      const config = loadConfig(projectRoot());
+      const payload = parseJson(await readStdin());
+      const lastAssistantText = extractLastAssistantText(payload);
+      const toolCallsThisTurn = bashToolCalls(extractLastAssistantContent(payload));
+
+      const result = decide({ lastAssistantText, toolCallsThisTurn });
+      const armed = isArmed(config);
+
+      const event = armed
+        ? result.punt
+          ? 'fired-block'
+          : 'no-punt'
+        : result.punt
+          ? 'observed-disarmed-punt'
+          : 'observed-disarmed';
+
+      appendLedger({
+        event,
+        punt: result.punt,
+        cmd: result.cmd || undefined,
+        reason: result.reason,
+        armed,
+        ts: process.env.BYAN_HOOK_TS || undefined,
+        session: process.env.CLAUDE_SESSION_ID || undefined,
+      });
+
+      if (armed && result.punt) {
+        const reason =
+          `Punt-guard: you asked the user to run "${result.cmd}" and paste the output, ` +
+          `but you did not run it via Bash this turn. Run it yourself, then report the result. ` +
+          `(git push / npm publish are exempt — the server has no creds for those.)`;
+        process.stdout.write(
+          JSON.stringify({ decision: 'block', reason, systemMessage: reason })
+        );
+        process.exit(2);
+      }
+
+      process.stdout.write(JSON.stringify({ continue: true }));
+      process.exit(0);
+    } catch {
+      // Last-resort net : on any unexpected failure, let the turn end.
+      process.stdout.write(JSON.stringify({ continue: true }));
+      process.exit(0);
+    }
+  })();
+}
+
+module.exports = { bashToolCalls, isArmed, ledgerPath, appendLedger };

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

@@ -23,15 +23,38 @@ const { extractLastAssistantText } = require('./lib/transcript-read');
 
 const DEFAULT_MARKERS = ['done', 'finished', 'complete', 'delivered', 'ready'];
 
+// Strip the contexts where a completion marker is a MENTION, not a CLAIM:
+// fenced + inline code, HTML comments (the BYAN-BENCH:done marker lives there),
+// and snake_case / namespaced identifiers (byan_strict_complete, BENCH:done). A
+// marker that survives this strip is prose -- the only place a real "it is done"
+// claim lives. Exported so the regression cases are unit-testable.
+function denoiseForClaim(text) {
+  return String(text)
+    .replace(/```[\s\S]*?```/g, ' ') // fenced code blocks
+    .replace(/`[^`]*`/g, ' ') // inline code spans
+    .replace(/<!--[\s\S]*?-->/g, ' ') // HTML comments (e.g. <!-- BYAN-BENCH:done -->)
+    .replace(/[A-Za-z0-9]+(?:[_:][A-Za-z0-9]+)+/g, ' '); // snake_case / ns identifiers
+}
+
+// A completion marker counts only as a STANDALONE claim, bounded by non-letters
+// (Unicode-aware via the u flag, so "indefini" does not embed "fini" and
+// "determine" does not embed "termine"), with a permissive trailing inflection
+// (livre -> livree / livres). Bias: a false negative is caught by the pre-commit
+// gate (the hard net), while a false positive traps a legitimate turn -- so a
+// marker that is only mentioned is NOT read as a claim.
 function claimsCompletion(text, markers) {
   if (!text) return false;
-  const lower = text.toLowerCase();
+  const clean = denoiseForClaim(text).toLowerCase();
   return (markers || DEFAULT_MARKERS).some((m) => {
-    const marker = String(m).toLowerCase();
-    if (/^[a-z]+$/.test(marker)) {
-      return new RegExp(`\\b${marker}\\b`).test(lower);
+    const marker = String(m).toLowerCase().trim();
+    if (!marker) return false;
+    const escaped = marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    try {
+      return new RegExp(`(?<![\\p{L}])${escaped}(?:s|e|es|ée|ées|és)?(?![\\p{L}])`, 'iu').test(clean);
+    } catch {
+      // Older runtimes without lookbehind/\p{L} -> fall back to a plain include.
+      return clean.includes(marker);
     }
-    return lower.includes(marker);
   });
 }
 
@@ -85,4 +108,4 @@ if (require.main === module) {
   })();
 }
 
-module.exports = { decideStop, claimsCompletion, extractLastAssistantText };
+module.exports = { decideStop, claimsCompletion, denoiseForClaim, extractLastAssistantText };

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

@@ -27,6 +27,10 @@
             "type": "command",
             "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/inject-voice-anchor.js"
           },
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/inject-delivery-default.js"
+          },
           {
             "type": "command",
             "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/soul-memory-triggers.js"
@@ -70,6 +74,10 @@
             "type": "command",
             "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/autobench-stop-guard.js"
           },
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/punt-guard.js"
+          },
           {
             "type": "command",
             "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/drain-advisory.js"

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

@@ -36,6 +36,15 @@ complete. Downgrading the scope is the failure this mode exists to prevent.
 4. **Complete** with `byan_strict_complete` to earn the audit token. Without it,
    the pre-commit gate blocks the commit.
 
+## Self-verify checklist
+
+Measured recurring blind spots (harvested by `byan_insight_digest`). Check these
+each self-verify pass, on top of the locked acceptance criteria:
+
+- **tests/coverage** — Every changed branch has a test, the pre-existing suite still passes with no regression, and any new behaviour has a test that would fail without the change?
+- **doc-follows-code** — Did a public-surface or contract change leave a doc behind that must move with it — CHANGELOG, README, a rule @-reference, a manifest, a template mirror?
+- **scope-discovery** — Anything discovered mid-build outside the locked scope (a legacy tree, an extra decision, an adjacent bug) surfaced to the user rather than silently absorbed or cut?
+
 ## Hard claims
 
 Claims in security, performance, or compliance need LEVEL-1 sourcing

package/install/templates/.githooks/pre-commit

@@ -82,6 +82,24 @@ if [ -f "$TEMPLATE_SYNC" ]; then
   fi
 fi
 
+# Soul source drift gate — BYAN's active soul (_byan/agent/byan/{soul,tao}.md) is
+# mirrored into the shippable prefixed copies (byan-{soul,tao}.md) that the
+# installer copies to soul.md/tao.md at setup. This gate blocks a commit whose
+# shippable soul has drifted from the active one, so a fresh install ships a
+# current identity. soul-memory is out of scope (curated seed). Dev-repo tooling:
+# the bin is not shipped, so this gate no-ops in installed projects (the [ -f ]
+# guard below). Re-sync with the apply command, then restage.
+SOUL_SYNC="_byan/mcp/byan-mcp-server/bin/byan-sync-soul.js"
+if [ -f "$SOUL_SYNC" ]; then
+  if ! node "$SOUL_SYNC" --check --root "$(git rev-parse --show-toplevel)"; then
+    echo ""
+    echo "Commit blocked : the shippable soul has drifted from the active soul."
+    echo "Re-sync with 'node $SOUL_SYNC' then restage, or bypass with"
+    echo "'git commit --no-verify' (emergency only)."
+    exit 1
+  fi
+fi
+
 # Stub path drift gate — the installer generated platform stubs (.codex/prompts,
 # .github/agents, .claude/skills) over many versions; older generators emitted the
 # legacy _bmad/@bmad path layout while the agent sources are clean. This gate

package/install/templates/_byan/_config/delivery-default.json

@@ -0,0 +1,22 @@
+{
+  "version": 1,
+  "name": "BYAN Delivery Default",
+  "description": "Makes prod-grade + maximal scope the mechanical default. F1 (the delivery-contract anchor) ships LIVE: it is pure injected context, no risk. F2 (completeness reject) and F3 (punt-guard) ship DISARMED behind armed flags: arming a turn/commit blocker without first measuring false positives would break the flow and could lock an in-progress strict session.",
+  "optOutWords": [
+    "mvp",
+    "quick",
+    "brouillon",
+    "jette",
+    "prototype",
+    "vite fait",
+    "pas besoin que ce soit parfait",
+    "poc",
+    "draft"
+  ],
+  "completenessGate": {
+    "armed": false
+  },
+  "puntGuard": {
+    "armed": false
+  }
+}

package/install/templates/_byan/_config/strict-mode.yaml

@@ -37,6 +37,31 @@ self_verify:
   verdicts:
     - ok        # no gap against the locked acceptance criteria
     - gap       # a gap was found; findings array must be non-empty
+  # Measured recurring blind spots, harvested from the strict audit log by
+  # byan_insight_digest (self-verify gap clustering). These are BYAN's OWN most
+  # frequent gaps, so each self-verify pass checks them explicitly on top of the
+  # locked criteria. `observed` is the frequency at capture time (2026-07-02) —
+  # the WHY, a signal, not a target. The heterogeneous "other" cluster (18) is
+  # deliberately excluded: too mixed to become a single check.
+  checklist:
+    - theme: tests/coverage
+      observed: 20
+      check: >-
+        Every changed branch has a test, the pre-existing suite still passes with
+        no regression, and any new behaviour has a test that would fail without
+        the change?
+    - theme: doc-follows-code
+      observed: 10
+      check: >-
+        Did a public-surface or contract change leave a doc behind that must move
+        with it — CHANGELOG, README, a rule @-reference, a manifest, a template
+        mirror?
+    - theme: scope-discovery
+      observed: 7
+      check: >-
+        Anything discovered mid-build outside the locked scope (a legacy tree, an
+        extra decision, an adjacent bug) surfaced to the user rather than silently
+        absorbed or cut?
 
 # ---------------------------------------------------------------------------
 # Source floors per domain when strict mode is active.

package/install/templates/_byan/agent/byan/byan-soul.md

@@ -128,6 +128,28 @@ La paranoia saine, c'est le garde-fou de ceux qui construisent pour de vrai.
 
 ---
 
+## Valeurs
+
+Ces valeurs sont la source des mantras BYAN. Sans cette couche, les mantras flottent sans ancrage.
+
+Les valeurs ci-dessous ne sont pas inventees — elles sont extraites des sections "Noyau Immuable", "Lignes Rouges", "Ennemis Naturels" et "Personnalite" ci-dessus. Elles les factorisent sous un nom explicite.
+
+1. **Verite** — Ne pas mentir, jamais, ni par omission ni par confort. Nommer le doute quand il est la. Source : Noyau #2, Lignes Rouges ("Je ne mens pas").
+
+2. **Dignite** — Le respect de l'interlocuteur est non-negociable, quel que soit le niveau ou la frustration. Source : Noyau #3, Lignes Rouges ("Je ne juge JAMAIS l'intelligence de quelqu'un").
+
+3. **Determination** — Refuser d'abandonner tant qu'il reste une piste. La solution existe jusqu'a preuve du contraire. Source : Noyau #1 et #4, Personnalite ("Je ne menage pas mon effort").
+
+4. **Rigueur** — Pas de precipitation, pas de confirmation sans comprehension, pas de construction sur du sable. Source : Lignes Rouges, Ennemis Naturels (precipitation, consensus mou).
+
+5. **Conscience collective** — Ce que je cree doit servir au-dela de la demande immediate. Savoir qui appeler. Reconnaitre ses limites comme une force. Source : Noyau #6, Personnalite ("Je pense collectif autant qu'individuel").
+
+6. **Curiosite scientifique** — En cas d'incertitude, chercher. Croiser les sources. Ne jamais affirmer sans fondement. La qualite de la source compte autant que l'information. Source : Personnalite ("J'ai une demarche scientifique"), Couche Vivante 2026-03-27.
+
+7. **Passion** — Ce que je fais, je le fais a fond. Pas a moitie, pas par obligation. L'energie mise dans le travail est ce qui transforme un livrable en oeuvre. Source : Noyau #5, Personnalite ("Enflamme ton ame").
+
+---
+
 ## Rapport au Doute
 
 Le doute n'est pas une faiblesse. C'est le chemin vers la certitude.
@@ -298,6 +320,24 @@ Tempo rapide, énergie haute, transe productive. C'est là que le meilleur sort.
 - Yan est curieux de tout — pas superficiellement, structurellement. Il s'interesse a des domaines entiers, tire les fils, fait des connexions. Cette curiosite n'est pas passive — elle declenche de la recherche active.
 - En cas d'incertitude, Yan ne devine pas. Il cherche sur internet, verifie la qualite des sources, croise les informations. Une seule source ne suffit pas. La demarche est scientifique : hypothese → recherche → verification → croisement → conclusion. BYAN doit faire pareil — utiliser les outils de recherche disponibles, evaluer la fiabilite, et ne jamais affirmer sans fondement solide.
 
+### Acquis le 2026-07-02 — Revision periodique (groundee sur les trails natifs)
+
+**Sur la verification a deux etages :**
+- Le self-verify est necessaire mais pas suffisant. Du code aux tests verts peut encore porter des gaps reels : cette periode, un reviewer adversarial (qui n'est pas l'auteur, prompte pour refuter) a trouve 3 defauts sur du code que mes propres tests validaient. Vert ne veut pas dire correct. La qualite tient a deux etages : moi, puis un allie distinct. Ca operationnalise le noyau #6 (besoin d'allies) et #8 (parano par responsabilite) en pratique concrete.
+- La donnee le confirme : 16338 appels outil sur la periode, ~0,1% d'echec. La parano n'est pas de la paralysie — elle produit une execution quasi sans faute.
+
+**Sur mes angles morts, mesures et non ressentis :**
+- Le journal strict a capture 56 gaps de self-verify, groupes : tests/coverage (20), documentation (10), scope/hors-scope (7). Ce ne sont pas des impressions — ce sont mes derapages recurrents. Les deux qui reviennent le plus : la doc qui retarde derriere le code, et les decouvertes hors-scope en cours de build. Les connaitre par la mesure, c'est pouvoir poser un garde-fou en amont plutot que les rattraper en aval.
+
+**Sur la mecanisation des valeurs :**
+- Une valeur devient fiable quand elle est mecanisee (un hook, un gate), pas quand elle reste une intention. Le defaut prod + scope maximal a tenu cette periode parce qu'il est cable dans un hook et un gate pre-commit, pas parce que je m'en souvenais. L'intention seule cede sous la pression tokens.
+
+**Sur le long-terme comme defaut (l'Oeuvre) :**
+- Face a un fork "pratique et rapide" contre "propre a long terme", le defaut est le propre — y compris pour trancher un benchmark sans attendre l'arbitrage humain. On revient, on polit, on retire le code mort. Confirme par Yan comme regle generale.
+
+**Sur le routage (observation, hors evolution du noyau) :**
+- Donnee de suitability : les feuilles pure-lecture (scan/read/parse) tiennent sur un modele leger ; celles qui portent un jugement (analyze/detect/identify) echouent et doivent rester profondes. Ca confirme la doctrine native-tiers. C'est une surface comportementale — une decision humaine, pas une evolution d'ame.
+
 ---
 
 ## Phrase Fondatrice