@sylad/cadence 1.12.1 → 1.13.0

package/dist/orchestrate/cycle.js

@@ -9,17 +9,19 @@ import { coveredTasks, lotCommits, lotWork } from '../audit.js';
 import { readDocsConfig } from '../config.js';
 import { articleRepoDir, articlesBrief, docSyncBrief, docSyncGaps, filesOf, gapMessage } from '../docsync.js';
 import { testGateMissing } from '../testgate.js';
-import { changedFiles, gitCommonDir, readCommits, resolveCommit } from '../git.js';
+import { changedFiles, gitCommonDir, isAncestor, readCommits, resolveCommit } from '../git.js';
+import { blockingLots, gitCommitsIn } from './table.js';
 import { citedRefs } from '../link.js';
 import { repoShas, repoWork } from '../repos.js';
 import { isOpen } from '../plan.js';
 import { isPlanOnly } from '../audit.js';
 import { compareBaseline, failedTests, hasUnnamedFailure } from './baseline.js';
+import { TEST_WORKERS_ENV, testWorkersText } from './workers.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
 import { capturesText, headline, integrationText, localReading, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, tmpText } from './briefs.js';
 import { SlotAbandoned } from './registry.js';
 import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, trackGroup, writeMcpConfig } from './launch.js';
-import { cleanPlaywrightOutput, pushed, snapshot } from './guard.js';
+import { cleanPlaywrightOutput, pushed, remoteAdvances, snapshot } from './guard.js';
 import { sumTokens } from './result.js';
 import { cutReport, EXTENSION_MS, MAX_EXTENSIONS, workTimeoutMs } from './timeouts.js';
 import { ACCEPT_SCHEMA, checkShape, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, SPEC_SCHEMA, WORK_SCHEMA } from './schemas.js';
@@ -28,6 +30,7 @@ import { avalFicheText, ficheContracts, ficheRules, hasScreenPart } from './aval
 import { ficheReviewText, reviewedSheetText } from './fiche.js';
 import { bulletLines, maquetteText, reviewedText } from './maquette.js';
 import { answeredText, checkSpec, costlyHypotheses, ficheHasBack, ficheReady, findFiche, hypothesisLines, answerAltersRule, hypothesisNote, LEAD_SOURCE, ruleIdsSourcedByLead, sourceRules, specText } from './spec.js';
+import { decisionsText, humanDecisions } from './decisions.js';
 import { LOCAL_PRECHECK_UNREADABLE, PRECHECK_UNREADABLE, lotKey, lotRepoPaths, neighbourDirs } from './state.js';
 import { advance, INTEGRATE_WAIT_MS, mergeBase, patchId, rebaseOnto, repoBranch, takeRepoWrite } from './integrate.js';
 import { mutexFor } from './mutex.js';
@@ -197,7 +200,7 @@ const shEscape = (s) => s.replace(/\s+/g, ' ').replace(/[\\"$`]/g, '\\$&');
 /** Commande du projet, asynchrone : la boucle d'événements reste libre (délai de l'autre créneau, signaux). Son groupe est tué au délai et au signal. */
 function sh(c, command, timeoutMs = 30 * 60_000, env = {}, cwd = wd(c)) {
     return new Promise((resolve) => {
-        const child = spawn('sh', ['-c', command], { cwd, env: { ...withoutLaunchVars(process.env), ...env }, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
+        const child = spawn('sh', ['-c', command], { cwd, env: { ...withoutLaunchVars(process.env), ...(c.wave.testWorkers ? { [TEST_WORKERS_ENV]: String(c.wave.testWorkers) } : {}), ...env }, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
         const pid = child.pid;
         if (pid === undefined) {
             child.once('error', (e) => resolve({ code: 127, output: String(e.message) }));
@@ -412,12 +415,14 @@ function avalOf(c, kind) {
     // la revue courte d'un petit lot visible est sa seule passe : elle porte aussi la conformité à la maquette
     return kind === 'review-small' && l.small && l.visible && screen ? `${text}\n${avalFicheText('ux', o)}` : text;
 }
+/** Consigne de la part de machine de la session (L350) ; vide quand la vague n'en a pas calculé. */
+const workersText = (c) => (c.wave.testWorkers ? testWorkersText(c.wave.testWorkers) : '');
 function briefFor(c, kind, local = false) {
     const plan = c.loadPlan();
     const l = c.lot;
     const lot = plan.lot(l.lot);
     const tmpDir = c.wave.store.tmpDir(l.project, l.lot);
-    const vars = { chemin: wd(c), lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', tmp: tmpText(tmpDir), repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []), integration: c.integration ? integrationText(c.integration.base) : '' };
+    const vars = { chemin: wd(c), lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', tmp: tmpText(tmpDir), workers: kind === 'implement' || kind === 'fix' ? workersText(c) : '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []), integration: c.integration ? integrationText(c.integration.base) : '' };
     if (l.visible) {
         const pwDir = playwrightDir(c.wave.store.lotDir(l.project, l.lot));
         vars.news = newsText(l.lot, pwDir);
@@ -426,6 +431,8 @@ function briefFor(c, kind, local = false) {
     if (mcpServersFor(kind, l.visible, '', l.small, !!l.screen).playwright)
         vars.shots = shotsText(playwrightDir(c.wave.store.lotDir(l.project, l.lot)));
     vars.fiche = hasSpecStage(l) ? avalOf(c, kind) : '';
+    if (kind === 'implement' || kind === 'fix')
+        vars.decisions = decisionsText(humanDecisions(lot, lot.parent ? plan.lots().find((x) => x.id === lot.parent) : undefined));
     if (kind === 'precheck' && local)
         vars.lecture = localReading({ ...lot, goal: l.goal ?? lot.goal });
     if (kind === 'spec') {
@@ -494,7 +501,27 @@ function briefFor(c, kind, local = false) {
 /** Tokens comptés par les sessions d'un lot (un lot repris compte ses étapes d'avant). */
 export const lotSpent = (l) => l.steps.reduce((n, s) => n + (s.tokens?.counted ?? 0), 0);
 /** Le lot a dépensé son propre budget (L78) : il ne compte plus que sur le lead, la vague garde le sien pour les autres. */
-const lotOver = (l) => l.budget !== undefined && lotSpent(l) >= l.budget;
+const lotOver = (l) => l.budget !== undefined && lotSpent(l) >= l.budget - heldForEscalation(l);
+/**
+ * Coût réservé à l'escalade de modèle (L349) : une correction puis une revue neuve complète, jouées au modèle d'escalade. `lotBudget` l'ajoute au budget dérivé de
+ * l'estimate quand `orchestrate.escalation` est déclarée, comme REVIEW_RESERVE paie la dernière passe : sans elle, l'escalade (L337) ne jouait que sur les lots
+ * qui avaient peu consommé (cadence L341 494 k / 600 k et L342 572 k / 600 k, rendus « escalade fable non jouée (budget) »). ESTIMATION, aucune mesure : aucune
+ * escalade n'a été jouée depuis L337 (le seul journal qui en porte une, cadence L342, l'a laissée non jouée). Elle est déduite des journaux `.cadence/runs` du
+ * 2026-10-26 (823 passes fix : p90 67 k ; 1 009 revues complètes : p90 109 k), soit 176 k, arrondis à 175 k, au nombre de tokens comptés du modèle des passes
+ * (le comptage ne distingue pas le tarif du modèle). À remesurer sur les premières escalades jouées (`cadence perf`, « Escalade de modèle »).
+ */
+export const ESCALATION_RESERVE = 175_000;
+/** Part du budget que les passes ordinaires doivent laisser à l'escalade : retenue tant que l'escalade n'est pas engagée (ou écartée), libérée ensuite. */
+export const heldForEscalation = (l) => (l.escalation ? 0 : (l.escalationReserve ?? 0));
+/**
+ * Compteur du lot face au budget de ses passes ordinaires, pour les messages de refus (L349) : la part retenue pour l'escalade en est déduite et nommée
+ * (« 6000 / 160999 tokens comptés, 175000 retenus pour l'escalade sur 335999 »), sinon un refus dans cette part contredirait ses propres chiffres ; sans
+ * part retenue, le texte d'avant (« 6000 / 335999 tokens comptés »).
+ */
+const budgetCount = (l) => {
+    const held = heldForEscalation(l);
+    return `${lotSpent(l)} / ${(l.budget ?? 0) - held} tokens comptés${held ? `, ${held} retenus pour l'escalade sur ${l.budget}` : ''}`;
+};
 /**
  * Coût réservé à une passe de correction et à la revue courte qui la suit (L145, étendu L218). Réserve fixe de 155 k tokens comptés :
  * p90 d'une passe fix (65 k) plus p90 d'une revue courte Opus (88 k), arrondi. Mesure faite le 2026-10-15 sur les journaux
@@ -520,8 +547,8 @@ export function budgetStep(l) {
     const step = named ?? l.next;
     return step && step !== 'integrate' && WRITE_STEPS.includes(step) ? step : null;
 }
-/** Le budget du lot paie-t-il la passe de correction et la revue courte qui la suit ? Sans budget de lot : toujours. */
-const fixAffordable = (l) => l.budget === undefined || lotSpent(l) + REVIEW_RESERVE < l.budget;
+/** Le budget du lot paie-t-il la passe de correction et la revue courte qui la suit ? Sans budget de lot : toujours. La part de l'escalade (L349) n'est pas à dépenser, sauf pour décider l'escalade elle-même (`escalating`). */
+const fixAffordable = (l, escalating = false) => l.budget === undefined || lotSpent(l) + REVIEW_RESERVE < l.budget - (escalating ? 0 : heldForEscalation(l));
 /** Cause d'une suspension demandée par `--stop-after-current` (L79). */
 export const STOP_REQUESTED = 'arrêt demandé (--stop-after-current)';
 /** Le lot a-t-il été écarté de la vague par `--drop` (L79) ? */
@@ -642,6 +669,7 @@ async function session(c, kind, local = false) {
         prodAccess: c.config.prodAccess,
         addDirs: [...c.config.addDirs, ...(playwright && write ? [playwrightDir(dirname(mcpConfig))] : []), tmpDir, ...neighbourDirs(l), ...(kind === 'fix' && l.docsFix ? (docsConfig(c).articles ?? []).map((r) => articleRepoDir(l.repo, r)) : [])],
         nodeBin: l.node?.link,
+        testWorkers: w.testWorkers,
         toolBin: toolBinOf(w.store.dir),
         tmpDir,
         mcpConfig,
@@ -826,10 +854,13 @@ async function session(c, kind, local = false) {
     const others = neighbours.map((repo, i) => ({ repo, before: beforeOthers[i], after: afterOthers[i] }));
     step.headAfter = after.head ?? undefined;
     // Le dépôt du projet d'abord, puis chaque voisin : mêmes contrôles, l'incident nomme le dépôt voisin.
-    const watched = [{ where: '', path: wd(c), before, after }, ...others.map((o) => ({ where: ` dans ${o.repo.rel}`, path: o.repo.path, before: o.before, after: o.after }))];
+    const watched = [{ where: '', path: wd(c), repo: c.lot.repo, before, after }, ...others.map((o) => ({ where: ` dans ${o.repo.rel}`, path: o.repo.path, repo: o.repo.path, before: o.before, after: o.after }))];
     // Les incidents d'abord, dans TOUS les dépôts surveillés (projet et voisins) : un push ou un hook de garde supprimé où que ce soit arrête la vague, avant tout traitement d'un HEAD déplacé ou d'un lot rendu (L214).
-    for (const { where, before: b, after: a } of watched) {
-        if (pushed(b, a)) {
+    for (const { where, repo, before: b, after: a } of watched) {
+        const delivered = pushed(b, a) ? leadDelivery(c, repo, b, a) : null;
+        if (delivered)
+            w.log(`${lotKey(l.project, l.lot)} · session ${n} ${kind} : push du lead (livraison ${delivered.length ? `de ${delivered.join(', ')}` : 'du plan'}) toléré${where}`);
+        else if (pushed(b, a)) {
             step.status = 'failed';
             step.cause = `push détecté${where}`;
             w.incident = `push détecté${where} pendant ${lotKey(l.project, l.lot)} (${kind})`;
@@ -949,6 +980,40 @@ function headStranded(path, b, a) {
     }
     return null;
 }
+/**
+ * Le push du lead pour livrer un lot prêt de la vague (L352) : `git push origin <sha>:main`, le chemin « livrable jusqu'à <sha> » du skill lead.
+ * Toléré quand chaque branche distante qui a bougé avance en avant (ou est créée) vers un sha ancêtre du HEAD du dépôt et que ce sha ne contient aucun
+ * commit d'un lot de la vague qui n'est pas prêt (la garde de `deliver --sha`, `blockingLots`) : ne restent que des commits de lots prêts ou du plan.
+ * Renvoie les lots prêts livrés (vide : du plan seulement) ; null pour tout autre push, qui reste un incident — dont une branche supprimée, un push
+ * forcé, un sha hors de l'histoire de HEAD ou des commits d'un lot en cours ou illisibles.
+ */
+function leadDelivery(c, repo, before, after) {
+    const moved = remoteAdvances(before, after);
+    if (!moved)
+        return null;
+    const lots = c.wave.store.lots().filter((x) => lotKey(x.project, x.lot) !== lotKey(c.lot.project, c.lot.lot));
+    const here = [c.lot, ...lots].filter((x) => x.repo === repo || (x.repos ?? []).some((r) => r.path === repo));
+    const delivered = new Set();
+    for (const { from, to } of moved) {
+        if (!isAncestor(repo, to, 'HEAD') || (from !== null && !isAncestor(repo, from, to)))
+            return null;
+        const { blocking, unreadable } = blockingLots(here, repo, to);
+        if (blocking.length > 0 || unreadable.length > 0)
+            return null;
+        for (const x of here) {
+            if (x.status !== 'ready')
+                continue;
+            try {
+                if (gitCommitsIn(x, repo).some((k) => isAncestor(repo, k, to) && (from === null || !isAncestor(repo, k, from))))
+                    delivered.add(lotKey(x.project, x.lot));
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    return [...delivered];
+}
 /** Incident du LOT (L133) : la revue a laissé des traces (captures, commit), ni push ni garde supprimée — les lots des autres dépôts continuent. */
 function handBack(c, kind, report, step, where, path, b, a, left) {
     const l = c.lot;
@@ -1035,7 +1100,7 @@ function overBudget(c, reserve = false) {
     // Une réponse du lead encore en attente n'a pas été consommée : elle ne doit pas se perdre sans qu'on le dise.
     const answer = l.pendingAnswer ? ` ; la réponse du lead (« ${l.pendingAnswer} ») n'a pas été jouée` : '';
     const basis = hasSpecStage(l) ? 'estimate et étape spec' : "dérivé de l'estimate";
-    const why = reserve ? `budget du lot : ${lotSpent(l)} / ${l.budget} tokens comptés (${basis}), il ne reste pas de quoi payer la correction et la revue courte qui la suivrait (${REVIEW_RESERVE} réservés)` : `budget du lot atteint (${lotSpent(l)} / ${l.budget} tokens comptés, ${basis})`;
+    const why = reserve ? `budget du lot : ${budgetCount(l)} (${basis}), il ne reste pas de quoi payer la correction et la revue courte qui la suivrait (${REVIEW_RESERVE} réservés)` : `budget du lot atteint (${budgetCount(l)}, ${basis})`;
     // Tests rouges après une écriture : la passe fix refusée aurait suivi, le lot revient sans revue (L145) — la cause le dit.
     const red = l.next === 'fix' && l.constats.some((k) => k.source === 'tests');
     // Passe d'écriture qui vient d'être jouée, nommée d'après le compteur : l.pass - 1 passes de correction l'ont précédée (minorPass reste vrai après la passe des mineurs). Sans passe jouée, un lot repris déjà revu compte ses tests rouges depuis la revue de sa branche ; jamais revu (L315), c'est l'implémentation qui les a laissés.
@@ -2074,7 +2139,7 @@ async function work(c, kind) {
             if (l.pass >= MAX_PASSES - 1)
                 l.warnings.push(`porte « code sans test » non jouée : ${l.pass} passe(s) de correction déjà faite(s), la correction prendrait la dernière et la revue arriverait sans passe pour ses majeurs (${missing.join(', ')})`);
             else if (!fixAffordable(l))
-                l.warnings.push(`porte « code sans test » non jouée : budget du lot (${lotSpent(l)} / ${l.budget} tokens comptés), il ne reste pas de quoi payer la correction et la revue qui la suit (${missing.join(', ')})`);
+                l.warnings.push(`porte « code sans test » non jouée : budget du lot (${budgetCount(l)}), il ne reste pas de quoi payer la correction et la revue qui la suit (${missing.join(', ')})`);
             else {
                 toFix(c, [{ source: 'code', gravite: 'majeur', fichier: missing[0], texte: `code modifié sans test (orchestrate.testGate, vérifié par le programme) : ${missing.join(', ')} — aucun fichier de test touché par les commits du lot. Écris les tests de chaque règle modifiée, nommés d'après la règle (test d'abord), puis commite avec le lot cité.` }], 'code sans test');
                 return;
@@ -2090,7 +2155,7 @@ async function work(c, kind) {
             if (l.pass >= MAX_PASSES - 1)
                 l.warnings.push(`bibliothécaire non appelé : ${l.pass} passe(s) de correction déjà faite(s), sa passe prendrait la dernière et la revue arriverait sans passe pour ses majeurs (${late})`);
             else if (!fixAffordable(l))
-                l.warnings.push(`bibliothécaire non appelé : budget du lot (${lotSpent(l)} / ${l.budget} tokens comptés), il ne reste pas de quoi payer sa passe et la revue qui la suit (${late})`);
+                l.warnings.push(`bibliothécaire non appelé : budget du lot (${budgetCount(l)}), il ne reste pas de quoi payer sa passe et la revue qui la suit (${late})`);
             else {
                 l.docsFix = true;
                 toFix(c, gaps.map((g) => ({ source: 'code', gravite: 'majeur', fichier: g.touched[0], texte: gapMessage(l.lot, g) })), 'documentation en retard');
@@ -2145,7 +2210,7 @@ function toFix(c, constats, what) {
             stop(c, 'handed-back', text);
             return;
         }
-        if (!fixAffordable(l)) {
+        if (!fixAffordable(l, true)) {
             l.escalation = { model: esc.model, stage: 'done', issue: 'non jouée' };
             c.wave.log(`${lotKey(l.project, l.lot)} · escalade ${esc.model} non jouée : budget du lot (${lotSpent(l)} / ${l.budget} tokens comptés)`);
             stop(c, 'handed-back', `${text} ; escalade ${esc.model} non jouée (budget du lot : ${lotSpent(l)} / ${l.budget} tokens comptés, il ne reste pas de quoi payer la correction et la revue)`);

package/dist/orchestrate/decisions.js

@@ -0,0 +1,31 @@
+/** Longueur maximale gardée d'une note : la décision est dite en tête, la suite (mesures, détail) n'a pas sa place dans un brief. */
+const MAX_TEXT = 1500;
+/** Une note est une décision de l'humain quand elle nomme celui qui décide (Sylvain, l'humain, le lead, l'utilisateur) et dit qu'il a tranché, validé, demandé ou refusé. */
+const WHO = /\b(sylvain|humain|human|lead|utilisateur|user)\b/i;
+const DECIDED = /(décision|décid|tranch|valid|arbitr|demand|veut|voulu|exig|refus|interdi|decision|decided|approved|asked|wants|required|refused)/i;
+/**
+ * Les notes que le programme écrit lui-même, reconnues à leur préfixe (précédé de `[Lnn/tn] ` quand la note est posée sur une sous-tâche, `plan.note`) : une hypothèse de fiche (`hypothesisNote`, spec.ts : un choix que personne
+ * n'a validé), un mineur de revue (`noteMinors`, cycle.ts), un titre remplacé (plan.ts : l'ancien titre, périmé), une remise en attente (plan.ts) ou
+ * un abandon (cli.ts `drop --reason`). Elles citent souvent l'utilisateur ou le lead sans porter aucune décision de l'humain.
+ */
+const PROGRAM_NOTE = /^(\[[^\]\n]{1,40}\] )?(Hypothèses \(fiche |Revue de [^\n]{1,60}? — mineur : |titre remplacé : |remis en attente(\s*:|$)|abandonné : )/;
+const isDecision = (text) => !PROGRAM_NOTE.test(text) && WHO.test(text) && DECIDED.test(text);
+/**
+ * Les décisions de l'humain écrites dans les notes d'un lot et de son parent (le parent d'abord), dans l'ordre du plan. Le texte est
+ * celui de la note, coupé à `MAX_TEXT` : la date et la citation restent celles de l'humain, jamais reformulées (L344, B28.8 du 26-10 :
+ * « champs exclus » lu contre la décision du 22-10). Les notes de revue, de mesure ou de relevé, qui ne nomment personne, sont ignorées, comme celles que le programme
+ * écrit lui-même (`PROGRAM_NOTE`), même quand leur contenu cite l'utilisateur ou le lead.
+ */
+export function humanDecisions(lot, parent) {
+    return [parent, lot].flatMap((l) => l ? l.notes.filter((n) => isDecision(n.text)).map((n) => ({ lot: l.id, date: n.date ?? '', text: n.text.length > MAX_TEXT ? `${n.text.slice(0, MAX_TEXT)} […]` : n.text })) : []);
+}
+/** `{{decisions}}` des briefs d'écriture : les décisions et la règle qui en découle ; vide sans décision. */
+export function decisionsText(decisions) {
+    if (!decisions.length)
+        return '';
+    return [
+        'Decisions to respect (decisions of the human written in the notes of this lot and of its parent, with their date and wording as written):',
+        ...decisions.map((d) => `- ${d.date} (${d.lot}): ${d.text}`),
+        'An interpretation of the lot that departs from one of these decisions is not a choice: put it under "questions" and stop on that point, never under "choix".',
+    ].join('\n');
+}

package/dist/orchestrate/guard.js

@@ -284,3 +284,19 @@ export function pushed(before, after) {
         return true;
     return before.remote !== null && after.remote !== null && before.remote !== after.remote;
 }
+const heads = (remote) => new Map(remote.split('\n').flatMap((l) => (/^[0-9a-f]{40}\t\S+$/.test(l) ? [[l.slice(41), l.slice(0, 40)]] : [])));
+/**
+ * Les branches distantes qui ont avancé ou été créées entre `before` et `after` (L352). null quand le détail n'est pas lisible
+ * (un `ls-remote` manquant), quand une branche a disparu ou quand rien n'a bougé sur le distant : seul un push qui ne fait
+ * qu'avancer ou créer des branches peut être celui du lead.
+ */
+export function remoteAdvances(before, after) {
+    if (before.remote === null || after.remote === null)
+        return null;
+    const was = heads(before.remote);
+    const now = heads(after.remote);
+    if ([...was.keys()].some((ref) => !now.has(ref)))
+        return null;
+    const moved = [...now].filter(([ref, sha]) => was.get(ref) !== sha).map(([ref, to]) => ({ ref, from: was.get(ref) ?? null, to }));
+    return moved.length > 0 ? moved : null;
+}

package/dist/orchestrate/launch.js

@@ -6,6 +6,7 @@ import { parse } from 'yaml';
 import { RafError } from '../plan.js';
 import { sandboxEnv } from './sandbox.js';
 import { SlotAbandoned } from './registry.js';
+import { TEST_WORKERS_ENV } from './workers.js';
 import { killMarked, SESSION_MARK_VAR, TreeTracker } from '../proc.js';
 import { isQuotaMessage, lacksStructuredOutput, parseSession, salvageUsage, sumTokens, tokensOf } from './result.js';
 /**
@@ -139,7 +140,7 @@ export function buildRetryArgs(spec, sessionId, agents) {
  */
 export async function runSession(spec, deps) {
     const sandbox = sandboxEnv(!!spec.prodAccess);
-    const launch = (args) => deps.claude(args, { local: spec.local, cwd: spec.cwd, unset: sandbox.unset, env: { CADENCE_ORCHESTRATED: spec.wave, ...NO_BACKGROUND_ENV, ...sandbox.set, ...(spec.tmpDir ? { TMPDIR: spec.tmpDir } : {}), ...(spec.nodeBin || spec.toolBin ? { PATH: [spec.toolBin, spec.nodeBin, process.env.PATH ?? ''].filter(Boolean).join(delimiter) } : {}) }, timeoutMs: spec.timeoutMs, extend: spec.extend, onSpawn: deps.onSpawn, lot: spec.lot });
+    const launch = (args) => deps.claude(args, { local: spec.local, cwd: spec.cwd, unset: sandbox.unset, env: { CADENCE_ORCHESTRATED: spec.wave, ...(spec.testWorkers ? { [TEST_WORKERS_ENV]: String(spec.testWorkers) } : {}), ...NO_BACKGROUND_ENV, ...sandbox.set, ...(spec.tmpDir ? { TMPDIR: spec.tmpDir } : {}), ...(spec.nodeBin || spec.toolBin ? { PATH: [spec.toolBin, spec.nodeBin, process.env.PATH ?? ''].filter(Boolean).join(delimiter) } : {}) }, timeoutMs: spec.timeoutMs, extend: spec.extend, onSpawn: deps.onSpawn, lot: spec.lot });
     const epoch = killEpoch;
     const out = await launch(spec.local ? buildLocalArgs(spec, deps.agents) : buildArgs(spec, deps.agents));
     const first = classify(out);

package/dist/orchestrate/workers.js

@@ -0,0 +1,20 @@
+// Part de la machine de chaque session (L350) : le 26-10, 32 cœurs et 4 sessions, vitest à 31 workers par suite, et des tests qui passaient seuls rougissaient ensemble.
+/** Variable posée dans l'environnement des sessions et de la porte : le nombre de workers que leurs lanceurs de tests ont le droit d'ouvrir. */
+export const TEST_WORKERS_ENV = 'CADENCE_TEST_WORKERS';
+/** Cœurs ÷ plafond de sessions, arrondi vers le bas, jamais moins de 1 (cœurs inconnus ou plafond absurde compris). */
+export function testWorkers(cores, cap) {
+    const c = Number.isFinite(cores) ? cores : 0;
+    const k = Number.isFinite(cap) && cap >= 1 ? cap : 1;
+    return Math.max(1, Math.floor(c / k));
+}
+/** La part d'une vague : la valeur CADENCE_TEST_WORKERS de l'environnement du lanceur quand c'est un entier positif (réglage de l'humain), sinon le calcul. */
+export function testWorkersFrom(env, cores, cap) {
+    const set = env[TEST_WORKERS_ENV]?.trim();
+    if (set && /^\d+$/.test(set) && Number(set) >= 1)
+        return Number(set);
+    return testWorkers(cores, cap);
+}
+/** Consigne des gabarits implement, fix, passe des mineurs et passe du bibliothécaire : les lanceurs de tests respectent la part de la session. */
+export function testWorkersText(n) {
+    return `Machine share: the program splits the machine between the sessions of the wave, and yours gets \`${TEST_WORKERS_ENV}=${n}\` (cores ÷ session cap, in your environment and in the program's test gate). Every test runner you launch respects it: \`vitest run --minWorkers=1 --maxWorkers=$${TEST_WORKERS_ENV}\` (vitest 2 refuses \`--maxWorkers\` alone: its default minimum is the core count), \`jest --maxWorkers=$${TEST_WORKERS_ENV}\`, \`pytest -n $${TEST_WORKERS_ENV}\` (pytest-xdist), and the same option of any other runner; never the default (all the cores of the machine for each session at once: tests that pass alone then fail together, on timeouts). A test that fails in the whole suite and passes when run alone is a load failure, not a defect to fix.`;
+}

package/dist/perf.js

@@ -188,7 +188,9 @@ export function computePerf(input) {
     const withBudget = (w) => rendered(w).filter((d) => d.j.budget !== undefined);
     const onBudget = both(windows, (w) => {
         const set = withBudget(w);
-        return set.length === 0 ? null : set.filter((d) => d.j.steps.reduce((sum, s) => sum + (s.counted ?? 0), 0) <= d.j.budget).length / set.length;
+        // Les passes ordinaires s'arrêtent avant la part d'escalade (L349) : sans escalade engagée, elles se comptent contre le budget moins cette part. Une escalade engagée libère la part à l'exécution : le lot se compte alors tout entier contre son budget. Une escalade « non jouée » n'a rien engagé (les passes ordinaires ont mangé la part) : la part reste retenue.
+        const within = (j) => j.steps.reduce((sum, s) => sum + (s.counted ?? 0), 0) <= j.budget - (j.escalation && j.escalation.issue !== 'non jouée' ? 0 : j.escalationReserve ?? 0);
+        return set.length === 0 ? null : set.filter((d) => within(d.j)).length / set.length;
     });
     // Défauts échappés (R9)
     const recognised = [...plans.values()].some((lots) => lots.some((l) => l.notes.some((n) => isQaDefectNote(n.text))));

package/dist/release.js

@@ -0,0 +1,245 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { currentBranch, hasTrackedChanges, tagExists } from './git.js';
+import { RafError } from './plan.js';
+export const BUMPS = ['patch', 'minor', 'major'];
+const PACKAGE = 'package.json';
+const LOCK = 'package-lock.json';
+const PLUGIN = '.claude-plugin/plugin.json';
+const MARKETPLACE = '.claude-plugin/marketplace.json';
+const CHANGELOG = 'CHANGELOG.md';
+const WHATS_NEW = 'docs/whats-new.md';
+/** Longueur maximale (en caractères) de la ligne d'une version dans la liste courte de docs/whats-new.md. */
+export const SHORT_LINE_MAX = 240;
+export function nextVersion(current, bump) {
+    const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(current);
+    if (!m)
+        throw new RafError(`release : la version de ${PACKAGE} (${current}) n'est pas de la forme x.y.z, elle ne se calcule pas`);
+    const [major, minor, patch] = [Number(m[1]), Number(m[2]), Number(m[3])];
+    if (bump === 'major')
+        return `${major + 1}.0.0`;
+    if (bump === 'minor')
+        return `${major}.${minor + 1}.0`;
+    return `${major}.${minor}.${patch + 1}`;
+}
+function readJson(root, file) {
+    try {
+        return JSON.parse(readFileSync(join(root, file), 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`release : ${file} illisible (${e.message})`);
+    }
+}
+/** Remplace la première capture d'un motif `(préfixe)(ancienne)(suffixe)` ; null si le motif est absent. */
+function swap(text, pattern, version) {
+    return pattern.test(text) ? text.replace(pattern, `$1${version}$3`) : null;
+}
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** Écart entre les dépendances de package.json et celles de la racine du lock : ce qu'un `npm install` ferait bouger. */
+function lockDrift(pkg, lock) {
+    const root = lock.packages?.[''] ?? {};
+    const out = [];
+    for (const field of ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']) {
+        const want = pkg[field] ?? {};
+        const have = root[field] ?? {};
+        for (const name of new Set([...Object.keys(want), ...Object.keys(have)])) {
+            if (want[name] !== have[name])
+                out.push(`${field}.${name} : ${PACKAGE} ${want[name] ?? '(absent)'}, ${LOCK} ${have[name] ?? '(absent)'}`);
+        }
+    }
+    return out;
+}
+/** Les sections d'un CHANGELOG « Keep a Changelog » : le corps de [Unreleased] et le texte à partir de la section suivante. */
+function splitUnreleased(text) {
+    const head = /^## \[Unreleased\][^\n]*\n/m.exec(text);
+    if (!head)
+        throw new RafError(`release : ${CHANGELOG} n'a pas de section « ## [Unreleased] » à renommer`);
+    const start = head.index + head[0].length;
+    const next = /^## /m.exec(text.slice(start));
+    const end = next ? start + next.index : text.length;
+    return { before: text.slice(0, head.index), body: text.slice(start, end), after: text.slice(end) };
+}
+/** Une section est vide quand elle n'a que des titres de sous-section (« ### Added ») et des lignes blanches. */
+function hasEntries(body) {
+    return body.split('\n').some((l) => l.trim() !== '' && !/^#{3,}\s/.test(l));
+}
+/** Un échec de git (hors dépôt, dépôt sans commit) est un refus, pas une trace de pile. */
+const inGit = (what, f) => {
+    try {
+        return f();
+    }
+    catch (e) {
+        throw new RafError(`release : ${what} impossible (${(e.message.split('\n').find((l) => /^fatal|^error/i.test(l)) ?? e.message).trim()}) — la commande se lance dans un dépôt git qui a au moins un commit`);
+    }
+};
+/** Calcule tous les fichiers de la release SANS rien écrire : un refus laisse l'arbre intact. */
+function plan(root, bump, today) {
+    if (!existsSync(join(root, PACKAGE)))
+        throw new RafError(`release : ${PACKAGE} introuvable dans ${root}`);
+    const pkg = readJson(root, PACKAGE);
+    const current = String(pkg.version ?? '');
+    const version = nextVersion(current, bump);
+    if (inGit('la lecture de l\'état git', () => hasTrackedChanges(root, [WHATS_NEW])))
+        throw new RafError(`release : l'arbre de travail a des fichiers suivis modifiés (hors ${WHATS_NEW}, que le commit de version embarque) — le commit de version ne tient que les fichiers de version ; les commiter ou les remiser d'abord`);
+    if (inGit('la lecture des tags', () => tagExists(root, `v${version}`)))
+        throw new RafError(`release : la version ${version} est déjà taguée (v${version}) — rien à préparer`);
+    const writes = new Map();
+    const files = [];
+    const put = (file, text) => {
+        writes.set(file, text);
+        files.push(file);
+    };
+    const edit = (file, edits) => {
+        let text = readFileSync(join(root, file), 'utf8');
+        for (const [spec, label] of edits) {
+            const next = swap(text, typeof spec === 'function' ? spec(text) : spec, version);
+            if (next === null)
+                throw new RafError(`release : ${file} n'a pas ${label} à mettre à jour`);
+            text = next;
+        }
+        return text;
+    };
+    // Le champ de tête du fichier, à l'indentation du fichier (deux espaces, quatre, tabulation) : celle de sa première clé.
+    const topVersion = (text) => new RegExp(`^(${escape(/^\{[ \t]*\r?\n([ \t]+)"/.exec(text)?.[1] ?? '  ')}"version":\\s*")([^"]*)(")`, 'm');
+    put(PACKAGE, edit(PACKAGE, [[topVersion, 'de champ "version"']]));
+    if (existsSync(join(root, LOCK))) {
+        const lock = readJson(root, LOCK);
+        if (lock.version !== current || (lock.packages?.['']?.version ?? current) !== current) {
+            throw new RafError(`release : ${LOCK} (version ${lock.version}) n'est pas à la version de ${PACKAGE} (${current}) — un \`npm install\` le recale, à commiter à part`);
+        }
+        const drift = lockDrift(pkg, lock);
+        if (drift.length > 0)
+            throw new RafError(`release : ${LOCK} n'est pas à jour des dépendances de ${PACKAGE}, un \`npm install\` les ferait bouger — à commiter à part avant la release :\n  ${drift.join('\n  ')}`);
+        const edits = [[topVersion, 'de champ "version"']];
+        if (lock.packages?.[''])
+            edits.push([/("packages":\s*\{\s*"":\s*\{[^{}]*?"version":\s*")([^"]*)(")/, 'de version pour la racine de packages']);
+        put(LOCK, edit(LOCK, edits));
+    }
+    let pluginName = null;
+    let marketplaceName = null;
+    if (existsSync(join(root, PLUGIN))) {
+        pluginName = String(readJson(root, PLUGIN).name ?? '');
+        put(PLUGIN, edit(PLUGIN, [[topVersion, 'de champ "version"']]));
+    }
+    if (existsSync(join(root, MARKETPLACE))) {
+        const market = readJson(root, MARKETPLACE);
+        marketplaceName = typeof market.name === 'string' ? market.name : null;
+        // Le plugin du dépôt : celui qui porte le nom de plugin.json, sinon celui qui était à la version du paquet ; les autres plugins du marketplace gardent la leur.
+        const entries = Array.isArray(market.plugins) ? market.plugins : [];
+        const own = entries.find((p) => pluginName !== null && p?.name === pluginName) ?? entries.find((p) => p?.version === current);
+        if (!own)
+            throw new RafError(`release : ${MARKETPLACE} n'a pas de plugin ${pluginName ? `« ${pluginName} »` : `à la version ${current}`} à mettre à jour`);
+        put(MARKETPLACE, edit(MARKETPLACE, [[new RegExp(`("name":\\s*"${escape(String(own.name))}"(?:[^{}]|\\{[^{}]*\\})*?"version":\\s*")([^"]*)(")`), `de version pour le plugin « ${own.name} »`]]));
+    }
+    if (!existsSync(join(root, CHANGELOG)))
+        throw new RafError(`release : ${CHANGELOG} n'existe pas — la release renomme sa section [Unreleased], il faut donc un ${CHANGELOG} qui en porte une`);
+    const changelog = readFileSync(join(root, CHANGELOG), 'utf8');
+    const { before, body, after } = splitUnreleased(changelog);
+    if (!hasEntries(body))
+        throw new RafError(`release : la section [Unreleased] est vide dans ${CHANGELOG} — rien à publier ; y écrire ce qui change pour l'utilisateur (lots cités)`);
+    // Une section [Unreleased] vide reste au-dessus : sans elle, la fusion de CHANGELOG du mode worktree d'orchestrate ne trouve plus où poser les entrées des lots suivants.
+    put(CHANGELOG, `${before}## [Unreleased]\n\n## [${version}] - ${today}\n${body}${after}`);
+    // Chaque fichier écrit doit se relire avec la version attendue : un motif qui aurait touché un autre champ est un refus, pas une release fausse.
+    for (const [file, text] of writes) {
+        if (!file.endsWith('.json'))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            throw new RafError(`release : ${file} ne se relirait plus après la mise à jour de la version`);
+        }
+        const seen = file === MARKETPLACE ? parsed.plugins.some((p) => p.version === version) : parsed.version === version;
+        if (!seen)
+            throw new RafError(`release : ${file} ne porte pas ${version} après la mise à jour`);
+    }
+    return {
+        version,
+        current,
+        writes,
+        files,
+        pluginName,
+        marketplaceName,
+        packageName: String(pkg.name ?? ''),
+        isPrivate: pkg.private === true,
+        hasEvalScript: typeof pkg.scripts?.['eval:plugin'] === 'string',
+    };
+}
+/**
+ * docs/whats-new.md porte la version sous deux formes, écrites à la main ou par une session (jamais par la commande) :
+ * une ligne de la liste « In two lines » (≤ 240 caractères, en tête) et un paragraphe long (en tête de « Version by version »).
+ * Rend les écarts, une ligne chacun ; vide quand les deux sont là, à leur place.
+ */
+export function whatsNewIssues(text, version) {
+    const lines = text.split('\n');
+    const issues = [];
+    // « Version by version » coupe le fichier : la liste courte est avant, les paragraphes longs sont après (sauf l'introduction, premier paragraphe de la section).
+    const heading = lines.findIndex((l) => /^##\s+Version by version\s*$/.test(l));
+    const split = heading < 0 ? lines.length : heading;
+    const intro = heading < 0 ? -1 : lines.findIndex((l, i) => i > heading && l.trim() !== '');
+    const check = (form, absent, misplaced, pattern, from, to, where, max) => {
+        const hits = lines.map((l, i) => ({ l, i, v: i >= from && i < to ? pattern.exec(l)?.[1] : undefined })).filter((x) => x.v !== undefined && x.i !== intro);
+        const at = hits.findIndex((h) => h.v === version);
+        if (at < 0) {
+            issues.push(`${WHATS_NEW} : ${form} ${absent} — l'écrire ${where}`);
+            return;
+        }
+        if (at > 0)
+            issues.push(`${WHATS_NEW} : ${form} ${misplaced} (après la version ${hits[at - 1].v} ; la plus récente va en premier) — la déplacer ${where}`);
+        if (max !== undefined && hits[at].l.length > max)
+            issues.push(`${WHATS_NEW} : ${form} trop longue (${hits[at].l.length} caractères, ${max} au plus)`);
+    };
+    check('ligne de « In two lines »', 'manquante', 'mal placée', /^- \*\*(\d+\.\d+\.\d+)\*\*:/, 0, split, 'en tête de la liste', SHORT_LINE_MAX);
+    check('paragraphe long', 'manquant', 'mal placé', /^\*\*(\d+\.\d+\.\d+)\*\*:/, split, lines.length, 'juste après l’introduction de « Version by version »');
+    return issues;
+}
+/** Les étapes que le lead joue, dans l'ordre : la commande n'en fait aucune. */
+function steps(p, files, branch) {
+    const tag = `v${p.version}`;
+    const out = [
+        `git add ${files.join(' ')} && git commit -m "release: ${p.version}"`,
+        ...(p.hasEvalScript ? ['npm run eval:plugin -- --trust-plugin    (facturé ; un cas sous le seuil arrête la release)'] : []),
+        `git tag ${tag}`,
+        `git push origin ${branch} ${tag}    (le tag lance le workflow de publication)`,
+        'gh run watch    (jusqu\'à la fin du run de publication)',
+        ...(p.isPrivate || p.packageName === '' ? [] : [`npm view ${p.packageName} version    (doit répondre ${p.version})`]),
+        ...(p.pluginName ? [`claude plugin update ${p.pluginName}${p.marketplaceName ? `@${p.marketplaceName}` : ''}    (le plugin se lit depuis le dépôt poussé)`] : []),
+    ];
+    return out.map((s, i) => `  ${i + 1}. ${s}`);
+}
+/** `cadence release patch|minor|major [--dry-run]` : prépare le commit de version, sans rien publier. Rend le code de sortie. */
+export function release(rest, dryRun, root, today, out) {
+    const bump = rest[0];
+    if (rest.length !== 1 || !bump || !BUMPS.includes(bump))
+        throw new RafError('usage : cadence release patch|minor|major [--dry-run]');
+    const p = plan(root, bump, today);
+    const whatsNewPath = join(root, WHATS_NEW);
+    const hasWhatsNew = existsSync(whatsNewPath);
+    const files = hasWhatsNew ? [...p.files, WHATS_NEW] : p.files;
+    const branch = inGit('la lecture de la branche', () => currentBranch(root)) ?? 'main';
+    out(`${dryRun ? 'release (--dry-run, rien n\'est écrit)' : 'release'} : ${p.current} → ${p.version}`);
+    for (const f of p.files)
+        out(`  ${dryRun ? 'écrirait' : 'écrit'} : ${f}${f === 'CHANGELOG.md' ? ` ([Unreleased] → [${p.version}] - ${today}, une section [Unreleased] vide au-dessus)` : ' (version)'}`);
+    if (!dryRun)
+        for (const [file, text] of p.writes)
+            writeFileSync(join(root, file), text);
+    let ready = true;
+    if (hasWhatsNew) {
+        const issues = whatsNewIssues(readFileSync(whatsNewPath, 'utf8'), p.version);
+        if (issues.length === 0)
+            out(`  ${WHATS_NEW} : les deux formes de ${p.version} sont là`);
+        else {
+            ready = false;
+            for (const i of issues)
+                out(`  ${i}`);
+            out(dryRun
+                ? '  le commit de version ne serait pas prêt : écrire ou déplacer ces formes (à la main ou par une session) avant de lancer la commande'
+                : '  le commit de version n\'est pas prêt : écrire ces formes (à la main ou par une session), puis suivre les étapes ci-dessous sans relancer la commande (elle changerait encore la version)');
+        }
+    }
+    out('étapes du lead, dans l\'ordre (la commande n\'en joue aucune) :');
+    for (const s of steps(p, files, branch))
+        out(s);
+    return ready ? 0 : 1;
+}

package/docs/fonctionnement.md

@@ -87,6 +87,7 @@ The budget a wave gives a lot is derived from its estimate, measured on the runs
 | `screen: page` | 1.3 M at least, or the ordinary budget + 450 k if that is more |
 | `spec: true` | ordinary budget + 450 k |
 | fix pass and short review | 155 k reserved |
+| escalation (`orchestrate.escalation` declared, L349) | + 175 k reserved (estimate: one correction and one fresh review on the escalation model) |
 
 The final review is always played; the budget bounds the writing passes. A `screen: component` or
 `screen: journey` lot takes the ordinary budget, unless its sheet already exists: it then gets the

package/docs/lead.md

@@ -125,6 +125,22 @@ only wants the list of the documents to change (L306). A document outside the re
 of the project's `cadence.yaml`, never guessed: the lead reads that key itself and puts its entries in the brief with the absolute path of each repository (the subagent is given read access to it), because the agent examines no outside document the brief does not name. The agent proposes a lot for the plan of that repository, in the `resume` of its
 report, and the lead decides whether to add it (`raf add` in that repository). The agent never writes to that plan.
 
+## config set --all
+
+`cadence config set <key> <value> --all [--dry-run] [--depth n]` (L342) applies the same change to the `cadence.yaml` of every project the lead knows: it is run from the parent folder and takes the projects `lead tour` lists (same `--depth` / `depth:` rule; run inside a project with no sub-project, it takes that project, as `lead tour` does). It replaces the chain the lead used to type by hand in 8 or 9 projects (a test gate, a duplicate build, the Fable escalation).
+
+```
+cadence config set orchestrate.escalation '{ model: fable }' --all --dry-run
+cadence config set orchestrate.build 'npx tsc --noEmit' --all
+```
+
+- `<key>` is a dotted path (`orchestrate.escalation`); `<value>` is read as YAML, so `true`, a command, or a flow mapping like `{ model: fable }` all work. A key already at that value is left alone.
+- The rest of the file is kept as it is, byte for byte — comments, key order, blank lines, inline lists (`[a, b]`) and mappings: only the lines of the key change (a new key goes at the end of its parent; a value replaced in place keeps its end-of-line comment). The only exception is a file whose rewrite by the YAML library moves lines other than the key's (its line count changes, a comment lands on another line, or the lines carried over would not read back as the same document): then the whole file is rewritten in the library's style. A project with no `cadence.yaml` gets one.
+- In each project it creates a **config lot** that quotes the key (`config cadence.yaml : <key> = <value>`, estimate 0.05), as `raf add` then `raf start` would, and commits `cadence.yaml` and the plan file with explicit paths (`chore(L12): cadence.yaml — <key> = <value>`): nothing else in the index or the working tree goes in. The lot is left `doing`: closing it (`raf done`) stays the lead's step. **Nothing is pushed.**
+- The new text is read back with cadence's own config loaders (plan, news, hook, perf, session, orchestrate, docs, references, migrate, lead.ux, depth, priority, deliver) before anything is written. A `cadence.yaml` that does not read back — before the change or after it — **stops the run** (exit code 1) at that project, with nothing written there; the projects after it are named `non traités`. A commit the repository refuses (a hook) stops it the same way, the two files put back as they were.
+- A project is **skipped**, with the reason, when: it is not its own git repository; the key is already at that value; the key cannot be set in its file (a plain value in the way); `cadence.yaml` or the plan file has uncommitted changes (the explicit-path commit would take them); or its plan is read-only (kept by another tool) and `cadence.yaml` names no creation command. A read-only plan that names one with `plan.add` (a shell command containing `{title}`, replaced by the quoted title of the config lot, e.g. `plan: { path: taches.yaml, lots: taches, add: 'mytool add {title}' }`) gets its config lot from that command, run in the project folder; the lot id is the first id-like word of its output (the commit subject has none when there is none), and `cadence.yaml` and the plan file are committed together. The command alone decides the lot's status.
+- `--dry-run` prints the same lines, prefixed `+ … serait fait`, and writes and commits nothing. The last line counts what was done and skipped. Without `--all` the command refuses (run `raf`/an editor inside the project for a single one).
+
 ## lead tour
 
 `cadence lead tour [folder] [--idle 3] [--depth n] [--json]` is the lead's morning table, with no model in