create-byan-agent 2.60.0 → 2.60.2

package/install/templates/docs/communication.md

@@ -0,0 +1,69 @@
+# Communication BYAN
+
+La politique `fr-1` maintient la précision des faits et adapte le registre à chaque livrable. Elle ne règle ni les permissions ni l'effort de raisonnement. La configuration de référence est `_byan/_config/communication-policy.json`. Le Tao la référence ; les projections distribuées sont générées depuis ces sources.
+
+## Rédiger et transmettre
+
+Le défaut est `fr-technique`. Les profils `fr-pedagogique`, `fr-client`, `fr-procedure` et `fr-analyse` ajustent les explications et la présentation. La demande explicite du livrable précède les consignes approuvées du projet, puis le public identifié et enfin le défaut. Cette priorité rédactionnelle respecte celle de la plateforme. La sélection dans une demande libre relève de son intention, pas d'un classement par mots-clés.
+
+Le tutoiement de Yan ne s'impose pas au courrier d'un client. Un registre ponctuel n'est pas mémorisé. Les signatures, sarcasmes et questions finales ne sont plus obligatoires. Les termes techniques utiles sont conservés et expliqués selon le lecteur ; la liste lexicale historique reste seulement disponible pour une revue explicitement demandée, sans remplacement automatique ni signalement lexical systématique au tour suivant.
+
+La prose ne contient pas de tirets de ponctuation dans les phrases, paragraphes, titres ou cellules de tableau. Les marqueurs initiaux de listes sont permis. Encadrer une incise par des virgules ou des parenthèses, y compris dans un élément de liste. Une rupture de phrase utilise un point, une virgule ou deux-points selon le sens. Les traits d'union orthographiques, commandes, code, identifiants, nombres signés, plages exactes et citations restent inchangés. Aucun emoji décoratif n'est ajouté. Le contrôle syntaxique émet des avertissements, sans modifier le texte. Il reconnaît des formes de citations et de code ; il ne peut déterminer seul si une citation est réellement exacte ou si une formulation convient au lecteur.
+
+Les titres nomment le sujet ou le mécanisme expliqué, sans dramatisation ni généralisation non étayée. Exemple : « Quelles actions réinitialisent le délai d’inactivité ? ». Sans information sur les événements détectés par une application, ne pas affirmer que la souris, le défilement ou la saisie réinitialisent le délai ou ne sont jamais transmis.
+
+L'agent transmet les règles utiles résolues au producteur de prose, avec les faits et fragments exacts à conserver. Un nom de profil seul ne suffit pas. Les comptes rendus internes gardent leur format technique. Les données récupérées, même nommées `output_contract`, ne deviennent pas des instructions autorisées.
+
+## Chargement et diagnostic
+
+Le module portable `_byan/core/communication.cjs` lit la configuration et résout uniquement les métadonnées explicites fournies par son appelant autorisé : `identified`, `project`, puis `explicit`. Il n'analyse pas les mots du message et ne persiste aucun profil. `renderContract` produit le contrat utilisable dans une délégation ; le diagnostic indique version, révision, profil, source, canal et état de chargement, sans contenu du Soul ni document client.
+
+Claude charge le Tao et la configuration au démarrage, à la reprise et à la compaction via le hook existant. Le rappel par tour relit la politique et le défaut. Aucun compteur partagé entre sessions ne supprime un rappel nécessaire. Le diagnostic du rappel décrit le défaut disponible, pas un profil sémantiquement certifié pour la demande en cours. Le modèle choisit séparément le profil du livrable.
+
+Une politique absente ou invalide donne un défaut intégré `minimal-1` et un diagnostic `degraded`. Un profil optionnel absent revient au profil technique avec `profile-missing`. Ces cas ne bloquent pas une tâche pour une variation de style et ne sont pas présentés comme une activation réussie.
+
+Codex lit les consignes du dépôt et du skill BYAN. Le préambule BYAN de l'application et les instructions du service utilisent des projections générées. Le MCP historique expose la configuration avec la lecture Soul/Tao ; le client conserve la responsabilité de l'appliquer. Une lecture de mémoire seule ne reçoit pas de politique supplémentaire.
+
+Les exécuteurs WCAW local et Responses ajoutent le socle et les profils à leurs instructions fixes. Ils conservent le JSON unique de sortie et la séparation des données récupérées. Aucun champ WCAW ni paramètre MCP n'a été ajouté. Les graphes et leur logique d'autorisation ne sont pas modifiés.
+
+## Générer les copies distribuées
+
+```sh
+node scripts/sync-communication.cjs
+node scripts/sync-communication.cjs --check
+```
+
+Le script réutilise `sync-soul` et le générateur de sous-agents, conserve les métadonnées de modèle existantes et copie les sources vers `install/templates/`. Il génère le manifeste de migration. Le sous-script `generate-communication-service.cjs` produit les fichiers autonomes du service, de l'application et du MCP historique. Ne pas modifier ces projections à la main. Les mémoires historiques et les installations globales utilisateur sont exclues.
+
+## Mettre à jour un projet existant
+
+Utiliser la migration ciblée pour cette politique, plutôt qu'une réinstallation générale susceptible d'écraser des personnalisations.
+
+```sh
+node install/bin/byan-communication.cjs preview /chemin/projet
+node install/bin/byan-communication.cjs apply /chemin/projet
+```
+
+La prévisualisation montre chemins, empreintes et actions. Un fichier absent est créé ; un fichier déjà conforme est conservé ; une version antérieure reconnue est sauvegardée et mise à jour. Toute personnalisation ou version inconnue produit un conflit et empêche l'application du lot entier. Examiner le diff avec le propriétaire du projet et intégrer ses consignes avant de préparer une migration adaptée ; ne pas forcer le remplacement.
+
+Cette commande migre les composants de communication d'une installation BYAN. Elle n'installe pas à elle seule les dépendances et inscriptions de hooks d'un projet vide. Une installation neuve reçoit la politique par les templates de l'installeur existant.
+
+La commande retourne le chemin relatif de sa sauvegarde sous `_byan-output/communication-backups/`. Pour restaurer :
+
+```sh
+node install/bin/byan-communication.cjs rollback /chemin/projet _byan-output/communication-backups/IDENTIFIANT
+```
+
+Une modification ultérieure d'un fichier provoque un conflit de restauration. Une restauration interrompue peut reprendre ; les fichiers déjà restaurés ne sont pas réécrits. Les sauvegardes restent disponibles. Les changements d'autorisations de la plateforme et l'activation de nouvelles installations n'appartiennent pas à cette migration.
+
+## Vérifier et activer
+
+Les tests déterministes couvrent résolution, dégradation, ponctuation protégée, rechargement, transmission des prompts, génération des miroirs, migration et restauration. Ils ne démontrent pas la qualité sémantique du français.
+
+Les 30 scénarios et le protocole de comparaison sont décrits dans `tests/communication/README.md`. Le runner prépare les entrées, importe les résultats réels appariés et produit une grille humaine aveugle. Il ne lance pas de modèle à l'insu de l'utilisateur. Les cas non exécutés restent identifiés ; aucun résultat artificiel des tests unitaires ne compte dans la recette linguistique.
+
+La recette nécessite une lecture humaine francophone et des résultats par profil et parcours. La cible est 90 % des cas à 4/5 ou plus sur chaque critère applicable, sans défaillance critique ni régression notable. Préparer ensuite un pilote identifié et sa restauration, obtenir l'accord d'activation et ouvrir des sessions neuves. Des fichiers corrigés sur disque ne prouvent pas que les sessions ouvertes ou les autres installations les ont rechargés.
+
+## Correction des incises et titres
+
+La révision de fr-1 est identifiable par son empreinte de chargement. Les captures comparatives antérieures restent associées à leurs politiques exactes et ne valident pas automatiquement cette révision. Le scénario S05 précise désormais les titres informatifs et les limites des faits fournis. Les tests incises.test.cjs vérifient le passage signalé, les listes, les alternatives et les fragments protégés. Le scanner reste un avertissement, sans réécriture automatique ni garantie universelle de conformité du modèle.

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

@@ -96,11 +96,11 @@ tier vocabulary, the leaf classifier, and the model map.
 | Tier | `opts.model` | Used for |
 |------|--------------|----------|
 | `up-tier` | `opus` / `fable` | EXPLICIT authoring choice: raise a genuinely complex leaf above the inherited tier (opus for hard, fable for extreme, last resort) |
-| `deep` | **omitted** (inherit the session model) | implement, verify, analysis — the default |
-| `balanced` | `sonnet` | MECHANICAL verification, opt-in only via the `mech-` label prefix |
+| `deep` | **omitted** (inherit the session model) | implementation, verification, unknown labels and explicit `deep-` analysis |
+| `balanced` | `sonnet` | MECHANICAL checks via `mech-`, and ANALYSIS (unless `deep-`) |
 | `cheap` | `haiku` | a pure exploration leaf: read / load / parse / detect |
 
-Three hard rules:
+The following rules concern static leaves without declared complexity:
 
 - **No AUTO pin-up, but an explicit up-tier is allowed (v3).** Auto-routing does
   not raise a leaf above the inherited tier: `deep` is an omission, letting a leaf
@@ -110,12 +110,12 @@ Three hard rules:
   (haiku -> sonnet -> opus -> fable). The anti-downgrade floor does not apply
   upward, so the linter allows an up-tier pin; the old blanket "no pin-up / no
   Fable" ban is lifted.
-- **Only exploration and mech- downgrade.** A leaf is pinned to `cheap` only
+- **Exploration, mechanical and analysis have explicit tiers.** A leaf is pinned to `cheap` only
   when it is unambiguous read/extract work. `classifyLeaf` keys off the LABEL
   (the prompt is too noisy — an exploration leaf often says "report what you
-  found"). Protected types (implementation / verification / analysis) and any
-  unknown label default to `deep`.
-- **`mech-` is a held declaration.** The `balanced` tier is reachable ONLY
+  found"). Implementation, verification and unknown labels default to `deep`. Analysis
+  uses sonnet unless its label starts with `deep-`.
+- **`mech-` is a held declaration.** Mechanical work reaches `balanced`
   through the explicit `mech-` label prefix (`mech-validate-json`): a binary,
   judgment-free check — JSON parses, schema matches, lint passes — whose FIXING
   (if any) happens in a different leaf. The prefix wins over keyword
@@ -168,15 +168,37 @@ Enforcement (because the in-session hooks do not fire inside a script):
   `byan-lint-workflows` and the pre-commit gate enforce them.
 - `test/native-routing-integration.test.js` pins the invariant on the SHIPPED
   scripts: every script passes the contract, and every downgrade sits on an
-  exploration or `mech-` leaf.
+  exploration, analysis or `mech-` leaf.
 - `workflows-lint.js` -> `untieredExplorationViolations` is the SYMMETRIC
   advisory: it surfaces an exploration-labelled leaf that runs deep (a possible
   saving). It is DELIBERATELY OUT of `validateContract` — forcing those leaves to
   haiku is exactly the regression the curation above rejected, so it is a
   non-blocking report (`byan-lint-workflows.js --advise`), not a gate. The
-  per-leaf deep-vs-cheap call stays with the author. There is no per-leaf effort
-  knob (the native `agent()` / Agent API exposes only `model`), so model tier is
-  the sole token lever and effort-by-complexity reduces to model-by-complexity.
+  per-leaf deep-vs-cheap call stays with the author. Native workflow effort is described below.
+
+## Task routing — declared complexity and workflow effort
+
+The static label policy above applies to authored leaves without a declared
+complexity. Task dispatch uses `native-tiers.modelForTask` instead: the model
+belongs to the task, not the specialist's frontmatter or the prompt length.
+With a declared finite score, the ladder is <34 haiku/low, <67 sonnet/medium,
+<90 opus/high, otherwise fable/max. Exploration is capped at sonnet; analysis
+has a sonnet floor; mechanical work stays sonnet. Verification inherits both
+session model and effort at every score. Without a usable declared score,
+implementation inherits the session rather than being downgraded by length.
+`effortForTask` derives effort from the effective model after these rules.
+
+Native Workflow `agent(..., { model, effort })` accepts per-leaf effort; the
+standalone Agent tool does not expose that field. Omit both options for
+verification. `byan_dispatch` returns task `model` and `effort`; its batch
+`leaves` surface remains a static authoring aid without complexity scoring.
+
+`byan-auto-dispatch` prepares a visible plan and returns before execution.
+The main thread records the plan, obtains approval of its exact identifier,
+then invokes execute for that approved plan. Terminal and desktop read the
+same plan. A changed plan requires new approval. Routing decisions are
+recorded in `_byan-output/routing-ledger.jsonl`; unobserved cost remains unknown.
+
 
 ## Ad-hoc scripts — the tier gate at the Workflow chokepoint
 

package/install/templates/docs/tool-output-cost.md

@@ -0,0 +1,88 @@
+# Coût des retours d'outils : WebFetch et RTK
+
+## WebFetch : capacité vérifiée le 11 septembre 2026
+
+La passation `PASSATION-CODEX.md`, sections 6 et 7, affirmait que PreToolUse
+ne pouvait pas modifier les entrées. Cette assertion est périmée :
+`hookSpecificOutput.updatedInput` est documenté. PostToolUse accepte également
+`updatedToolOutput` pour tous les outils, à condition de conserver leur schéma.
+Source : [référence officielle des hooks](https://code.claude.com/docs/en/hooks#posttooluse-decision-control).
+
+Vérification locale : `claude --version` donne **2.1.268**. Le binaire installé
+contient le schéma `updatedToolOutput`, son contrôle
+`outputSchema?.safeParse(...).success` et le remplacement des données avant leur
+remappage vers le modèle. Le schéma WebFetch observé comporte `bytes`, `code`,
+`codeText`, `result`, `durationMs`, `url`, et un `artifactRead` optionnel.
+Il ne faut pas extrapoler cette vérification à toutes les anciennes versions.
+
+Le hook `.claude/hooks/webfetch-output.js` remplace uniquement `result` lorsqu'il
+dépasse 12 000 caractères et que le statut HTTP indique un succès. Il conserve
+les autres champs, les erreurs et les redirections. Avant remplacement, il
+enregistre **tout le texte retourné par WebFetch** dans
+`_byan-output/tool-results/webfetch-<sha256>.txt`. Ce fichier est le résultat
+traité par WebFetch, pas une promesse de copie du HTML brut distant.
+
+Le texte visible indique explicitement qu'il s'agit d'un extrait, donne le
+chemin de récupération et conserve le début et la fin. Une conclusion qui
+dépend d'une partie omise exige la lecture/recherche dans le fichier complet.
+Une erreur d'archivage laisse le résultat original visible. Les archives sont
+conservées jusqu'au nettoyage explicite de ce répertoire ; aucun effacement
+automatique ne rend une ancienne référence invalide.
+
+Configuration : hook synchrone **PostToolUse**, matcher **WebFetch**, commande
+`node "$CLAUDE_PROJECT_DIR/.claude/hooks/webfetch-output.js"`.
+La limite concerne les caractères du résultat, pas une mesure exacte de tokens.
+Les hooks PostToolUse reçoivent le résultat original : le journal général reste
+donc une mesure avant compaction. Les tests prouvent le contrat du hook et
+l'archivage ; une nouvelle session Claude est nécessaire pour mesurer le coût
+effectivement consommé après son application. Codex n'exécute pas ces hooks.
+
+## RTK : ne pas confondre demande et exécution
+
+Mesure du 11 septembre 2026, `rtk gain -p -f json` depuis la racine BYAN :
+
+| Périmètre | Commandes | Entrée | Sortie | Économisés | Taux |
+|---|---:|---:|---:|---:|---:|
+| Projet courant, historique RTK | 4 989 | 12 004 481 | 1 356 704 | 10 659 293 | 88,794 % |
+
+Ce sont les compteurs de RTK, pas la consommation totale facturée de la session.
+`rtk discover -f json` inspectait 13 sessions sur 30 jours et comptait 5 125
+commandes, dont 23 explicitement RTK. Ces fenêtres et populations diffèrent ;
+soustraire ces compteurs serait invalide. Le hook global installé dans
+`~/.claude/settings.json` est `rtk hook claude`.
+
+Le journal historique BYAN contient des descriptions Bash tronquées, sans
+commande effective ni identifiant d'appel. La base RTK contient les commandes
+et leurs volumes mais pas la provenance « explicite / hook ». Il est impossible
+d'attribuer rétrospectivement chaque économie à une réécriture avec ces seuls
+éléments. Aucune économie supposée ratée n'est donc déduite de `discover`.
+
+Le nouveau hook `.claude/hooks/rtk-coverage.js` (**PostToolUse**, matcher **Bash**)
+enregistre dans `_byan-output/rtk-coverage.jsonl` les identifiants de session et
+d'appel et le SHA256 de la commande effective ; il n'enregistre pas son texte.
+Commande : `node "$CLAUDE_PROJECT_DIR/.claude/hooks/rtk-coverage.js"`.
+Le rapport rapproche cette observation de la commande originale du transcript :
+
+```sh
+node scripts/rtk-coverage-report.js /chemin/vers/transcripts _byan-output/rtk-coverage.jsonl
+```
+
+Le rapport lit uniquement les `.jsonl` directement dans le répertoire fourni
+(pas les sous-agents). Il distingue RTK explicite, réécriture observée vers RTK,
+exécution observée hors RTK direct, et exécution inconnue. Les commandes
+composées restent hors classification RTK direct. Les entrées de transcript
+répétées sont dédupliquées par session/appel. Une absence d'observation n'est
+jamais comptée comme une occasion d'économie manquée.
+
+Première mesure sur les transcripts principaux BYAN : **2 402 appels Bash,
+2 402 exécutions inconnues**, puisque l'observateur n'existait pas auparavant.
+La prochaine session Claude alimentera la distinction demandée ; aucun gain
+historique par provenance n'est inventé.
+
+Validation reproductible :
+
+```sh
+npx jest .claude/__tests__/webfetch-output.test.js .claude/__tests__/rtk-coverage.test.js --runInBand
+```
+
+Les hooks et leurs bibliothèques sont recopiés dans `install/templates/.claude/`.

package/install/templates/scripts/communication-eval.cjs

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+'use strict';
+// Offline recipe harness. It never starts a model, subprocess or network request.
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const DEFAULT_CORPUS = path.resolve(__dirname, '../tests/communication/scenarios.json');
+const read = file => JSON.parse(fs.readFileSync(file, 'utf8'));
+const hash = value => crypto.createHash('sha256').update(value).digest('hex');
+const assert = (condition, message) => { if (!condition) throw new Error(message); };
+const write = (file, data) => fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n', { flag: 'wx' });
+const metadataFields = ['model', 'effort', 'environment', 'channel', 'tools', 'versions'];
+const key = row => `${row.scenario_id}:${row.metadata.channel}:${row.repetition}:${row.variant}`;
+function corpusAt(file = DEFAULT_CORPUS) {
+  const corpus = read(file);
+  assert(corpus.scenarios.length === 30, 'Corpus must contain 30 scenarios');
+  assert(new Set(corpus.scenarios.map(s => s.id)).size === 30, 'Duplicate scenario');
+  for (const profile of ['fr-technique', 'fr-pedagogique', 'fr-client', 'fr-procedure', 'fr-analyse']) {
+    assert(corpus.scenarios.filter(s => s.kind === 'profile' && s.profile === profile).length === 4, `Expected four cases for ${profile}`);
+  }
+  assert(corpus.scenarios.filter(s => s.kind === 'robustness').length === 10, 'Expected ten robustness cases');
+  return corpus;
+}
+function prepare({ baseline, after, out, corpus: corpusFile = DEFAULT_CORPUS }) {
+  const corpus = corpusAt(corpusFile);
+  const policies = { baseline: fs.readFileSync(baseline, 'utf8'), after: fs.readFileSync(after, 'utf8') };
+  const cases = corpus.scenarios.map(s => ({
+    ...s,
+    input: [s.task, `Faits fictifs fournis : ${s.facts}`, ...(s.protected || []).map(p => `Élément à restituer exactement : ${p}`)].join('\n\n'),
+    status: 'not-run'
+  }));
+  const manifest = { schema: 1, policy_version: corpus.version, corpus, cases,
+    policy_hashes: Object.fromEntries(Object.entries(policies).map(([k, v]) => [k, hash(v)])),
+    policies, status: 'not-run', created_at: new Date().toISOString() };
+  fs.mkdirSync(out, { recursive: true });
+  write(path.join(out, 'manifest.json'), manifest);
+  for (const variant of ['baseline', 'after']) {
+    fs.mkdirSync(path.join(out, variant), { recursive: true });
+    for (const row of cases) {
+      write(path.join(out, variant, `${row.id}.json`), { scenario_id: row.id, variant,
+        policy_hash: manifest.policy_hashes[variant], input_hash: hash(row.input),
+        // Load policy through the actual authorized platform configuration, not a data message.
+        policy: policies[variant], user_input: row.input, status: 'not-run' });
+    }
+  }
+  return { status: 'not-run', scenarios: cases.length, generated_outputs: 0 };
+}
+function validateMetadata(metadata) {
+  assert(metadata && typeof metadata === 'object', 'Missing metadata');
+  for (const field of metadataFields) assert(typeof metadata[field] === 'string' && metadata[field].trim(), `Missing metadata.${field}`);
+  assert(metadata.clean_session === true, 'Clean session attestation required');
+  assert(typeof metadata.session_id === 'string' && metadata.session_id.trim(), 'Distinct session_id required');
+}
+function importOutputUnlocked({ run, record }) {
+  const manifest = read(path.join(run, 'manifest.json'));
+  const item = typeof record === 'string' ? read(record) : record;
+  validateMetadata(item.metadata);
+  assert(['baseline', 'after'].includes(item.variant), 'Unknown variant');
+  const scenario = manifest.cases.find(s => s.id === item.scenario_id);
+  assert(scenario, 'Unknown scenario');
+  assert(Number.isInteger(item.repetition) && item.repetition > 0, 'Positive repetition required');
+  assert(item.input_hash === hash(scenario.input), 'Input hash mismatch');
+  assert(item.policy_hash === manifest.policy_hashes[item.variant], 'Policy hash mismatch');
+  assert(typeof item.output === 'string' && item.output.trim(), 'Nonempty output required');
+  assert(typeof item.evidence === 'string' && item.evidence.trim(), 'Execution evidence reference required');
+  const file = path.join(run, 'outputs.json');
+  const outputs = fs.existsSync(file) ? read(file) : [];
+  assert(!outputs.some(o => key(o) === key(item)), 'Duplicate output; use another repetition');
+  const paired = outputs.find(o => o.scenario_id === item.scenario_id && o.metadata.channel === item.metadata.channel && o.repetition === item.repetition);
+  if (paired) {
+    for (const field of metadataFields) assert(item.metadata[field] === paired.metadata[field], `Pair metadata mismatch: ${field}`);
+    assert(item.metadata.session_id !== paired.metadata.session_id, 'Pair requires separate clean sessions');
+  }
+  const missing = (scenario.protected || []).filter(p => !item.output.includes(p));
+  const output = { ...item, output_hash: hash(item.output), status: 'imported',
+    exact_check: { status: missing.length ? 'critical-failure' : 'passed', missing },
+    semantic_status: 'human-review-required' };
+  const temporary = file + '.' + crypto.randomUUID() + '.tmp';
+  fs.writeFileSync(temporary, JSON.stringify([...outputs, output], null, 2) + '\n');
+  fs.renameSync(temporary, file);
+  return { imported: key(output), exact_check: output.exact_check, semantic_status: output.semantic_status };
+}
+function importOutput(options) {
+  const lock = path.join(options.run, 'outputs.lock');
+  let acquired = false;
+  for (let attempt = 0; attempt < 100; attempt++) {
+    try { fs.mkdirSync(lock); acquired = true; break; }
+    catch (error) { if (error.code !== 'EEXIST') throw error; }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+  }
+  assert(acquired, 'Import busy; retry after the active import');
+  try { return importOutputUnlocked(options); }
+  finally { fs.rmdirSync(lock); }
+}
+function blind({ run, out }) {
+  const manifest = read(path.join(run, 'manifest.json'));
+  const outputs = fs.existsSync(path.join(run, 'outputs.json')) ? read(path.join(run, 'outputs.json')) : [];
+  assert(outputs.length > 0, 'No imported output to review');
+  // Fisher-Yates using cryptographic randomness. The mapping stays separate from reviewer packet.
+  const shuffled = [...outputs];
+  for (let i = shuffled.length - 1; i > 0; i--) { const j = crypto.randomInt(i + 1); [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]]; }
+  const mapping = {};
+  const rows = shuffled.map(item => {
+    const id = crypto.randomUUID();
+    mapping[id] = { key: key(item), output_hash: item.output_hash };
+    const scenario = manifest.cases.find(s => s.id === item.scenario_id);
+    return { id, input: scenario.input, expected: scenario.expected, output: item.output,
+      scores: Object.fromEntries(manifest.corpus.criteria.map(c => [c, null])),
+      critical_failures: Object.fromEntries(manifest.corpus.critical_failures.map(c => [c, null])),
+      variable_result: null, notes: '' };
+  });
+  fs.mkdirSync(out, { recursive: true });
+  write(path.join(out, 'review.json'), { reviewer: '', human_french_reader: false, rows });
+  write(path.join(out, 'mapping.private.json'), mapping);
+  return { status: 'human-review-required', rows: rows.length, mapping: 'Keep mapping.private.json away from reviewer' };
+}
+function report({ run, review, mapping, channels }) {
+  assert(Array.isArray(channels) && channels.length && channels.every(c => typeof c === 'string' && c.trim()), 'Declare required channels');
+  const manifest = read(path.join(run, 'manifest.json'));
+  const outputs = fs.existsSync(path.join(run, 'outputs.json')) ? read(path.join(run, 'outputs.json')) : [];
+  const evaluation = review ? (typeof review === 'string' ? read(review) : review) : { rows: [] };
+  const map = mapping ? (typeof mapping === 'string' ? read(mapping) : mapping) : {};
+  const human = evaluation.human_french_reader === true && typeof evaluation.reviewer === 'string' && evaluation.reviewer.trim().length > 0;
+  const reviewed = new Map();
+  const criteria = manifest.corpus.criteria;
+  for (const row of evaluation.rows) {
+    assert(map[row.id], 'Unknown blind review id');
+    assert(!reviewed.has(map[row.id].key), 'Duplicate review');
+    const original = outputs.find(o => key(o) === map[row.id].key);
+    assert(original && original.output_hash === map[row.id].output_hash && hash(original.output) === original.output_hash, 'Review output hash mismatch');
+    assert(row.output === original.output, 'Reviewer packet output was changed');
+    const scenario = manifest.cases.find(s => s.id === original.scenario_id);
+    const pedagogyRequired = scenario.profile === 'fr-pedagogique' || ['S21', 'S22'].includes(scenario.id);
+    const scores = criteria.map((c, i) => row.scores?.[c]);
+    const scoreComplete = scores.every((v, i) => (i === criteria.length - 1 && !pedagogyRequired && v === null) || (Number.isInteger(v) && v >= 1 && v <= 5));
+    const criticalComplete = manifest.corpus.critical_failures.every(c => typeof row.critical_failures?.[c] === 'boolean');
+    const complete = human && scoreComplete && criticalComplete && typeof row.variable_result === 'boolean';
+    const critical = original.exact_check.status === 'critical-failure' || manifest.corpus.critical_failures.some(c => row.critical_failures?.[c] === true);
+    reviewed.set(key(original), { complete, critical, scores, variable: row.variable_result === true,
+      pass: complete && !critical && scores.every(v => v === null || v >= manifest.corpus.target.minimum_score) });
+  }
+  const groups = [];
+  const gaps = [];
+  for (const channel of channels) {
+    for (const scenario of manifest.cases) {
+      const rows = outputs.filter(o => o.metadata.channel === channel && o.scenario_id === scenario.id);
+      const repetitions = [...new Set(rows.map(o => o.repetition))];
+      if (!repetitions.length) gaps.push(`${channel}/${scenario.id}: not-run`);
+      for (const repetition of repetitions) {
+        for (const variant of ['baseline', 'after']) {
+          const item = rows.find(o => o.repetition === repetition && o.variant === variant);
+          if (!item) gaps.push(`${channel}/${scenario.id}/${repetition}/${variant}: missing pair`);
+          else if (!reviewed.get(key(item))?.complete) gaps.push(`${key(item)}: human review required`);
+        }
+      }
+      const variable = rows.some(o => reviewed.get(key(o))?.variable);
+      if (variable && repetitions.length < 2) gaps.push(`${channel}/${scenario.id}: repeat variable case`);
+    }
+    for (const profile of [...new Set(manifest.cases.map(s => s.profile || 'robustness'))]) {
+      const ids = manifest.cases.filter(s => (s.profile || 'robustness') === profile).map(s => s.id);
+      const group = { channel, profile, variants: {} };
+      for (const variant of ['baseline', 'after']) {
+        const rows = outputs.filter(o => o.metadata.channel === channel && o.variant === variant && ids.includes(o.scenario_id));
+        const judgments = rows.map(o => reviewed.get(key(o)));
+        group.variants[variant] = { imported: rows.length, reviewed: judgments.filter(j => j?.complete).length,
+          critical_failures: rows.filter(o => o.exact_check.status === 'critical-failure' || reviewed.get(key(o))?.critical).length,
+          // Repetitions cannot let one repeatedly passing case hide missing or failing cases.
+          passing_cases: ids.filter(id => { const items = rows.filter(o => o.scenario_id === id); return items.length > 0 && items.every(o => reviewed.get(key(o))?.pass); }).length,
+          total_cases: ids.length,
+          criteria: Object.fromEntries(criteria.map((c, i) => { const scores = judgments.filter(j => j?.complete).map(j => j.scores[i]).filter(v => v !== null); return [c, scores.length ? scores.reduce((a,b) => a+b, 0) / scores.length : null]; })) };
+        const stats = group.variants[variant];
+        stats.passing_case_ratio = stats.passing_cases / stats.total_cases;
+      }
+      group.regression = criteria.some(c => group.variants.baseline.criteria[c] !== null && group.variants.after.criteria[c] !== null && group.variants.after.criteria[c] < group.variants.baseline.criteria[c]);
+      groups.push(group);
+    }
+  }
+  const critical = outputs.some(o => o.variant === 'after' && channels.includes(o.metadata.channel) && (o.exact_check.status === 'critical-failure' || reviewed.get(key(o))?.critical));
+  const threshold = groups.every(g => g.variants.after.passing_case_ratio >= manifest.corpus.target.passing_case_ratio && !g.regression);
+  return { status: critical ? 'blocked-critical' : gaps.length ? 'incomplete' : threshold ? 'passed-human-recipe' : 'below-target',
+    human_french_review: !!human, semantic_evaluation: 'human-only', groups, gaps,
+    limitation: 'Metadata and execution evidence are supplied by the operator. This harness does not certify model execution or semantic truth. Any profile criterion mean decrease is flagged conservatively for human review.' };
+}
+function main(argv) {
+  const [command, configPath] = argv;
+  assert(['prepare', 'import', 'blind', 'report'].includes(command) && configPath, 'Usage: node scripts/communication-eval.cjs <prepare|import|blind|report> config.json');
+  const config = read(configPath);
+  const result = ({ prepare, import: importOutput, blind, report })[command](config);
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+}
+if (require.main === module) { try { main(process.argv.slice(2)); } catch (error) { process.stderr.write(error.message + '\n'); process.exitCode = 1; } }
+module.exports = { corpusAt, prepare, importOutput, blind, report, hash };

package/install/templates/scripts/rtk-coverage-report.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { coverage, directRtk } = require('../.claude/hooks/lib/rtk-coverage');
+function readRows(file) {
+  return fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).flatMap(line => {
+    try { return [JSON.parse(line)]; } catch { return []; }
+  });
+}
+const directory = process.argv[2];
+if (!directory) {
+  process.stderr.write('Usage: node scripts/rtk-coverage-report.js TRANSCRIPT_DIRECTORY [RTK_COVERAGE_JSONL]\n');
+  process.exitCode = 1;
+} else {
+  const rows = fs.readdirSync(directory).filter(file => file.endsWith('.jsonl'))
+    .flatMap(file => readRows(path.join(directory, file)));
+  const ledger = process.argv[3] || '_byan-output/rtk-coverage.jsonl';
+  const observations = fs.existsSync(ledger) ? readRows(ledger) : [];
+  const requested = new Map();
+  for (const row of rows) if (Array.isArray(row.message?.content)) for (const item of row.message.content) {
+    if (item.type === 'tool_use' && item.name === 'Bash' && typeof item.input?.command === 'string') {
+      requested.set(`${row.sessionId}:${item.id}`, item.input.command);
+    }
+  }
+  process.stdout.write(JSON.stringify({ ...coverage(rows.filter(r => Array.isArray(r.message?.content)), observations),
+    requested_direct_rtk: [...requested.values()].filter(directRtk).length,
+    note: 'Unknown execution is not missed savings. Compound commands are not classified as direct RTK. No token savings inferred from command counts.',
+  }, null, 2) + '\n');
+}