@sylad/cadence 1.2.0 → 1.4.0

package/dist/corrections.js

@@ -86,7 +86,7 @@ export function readRuns(runsDir, until) {
 const tally = () => ({ lots: 0, atLeast1: 0, atLeast2: 0, passes: 0 });
 const causes = () => ({ ...Object.fromEntries([...CAUSES, 'sans-constat', 'non-classe'].map((c) => [c, 0])) });
 export function measure(data, cache) {
-    const m = { total: tally(), byProject: {}, byVisibility: { visible: tally(), hidden: tally() }, byCause: causes(), byProjectCause: {}, agreement: { reviewed: 0, agree: 0 } };
+    const m = { total: tally(), byProject: {}, byVisibility: { visible: tally(), hidden: tally() }, byCause: causes(), byVisibilityCause: { visible: causes(), hidden: causes() }, byProjectCause: {}, agreement: { reviewed: 0, agree: 0 } };
     for (const l of data.lots) {
         const groups = [m.total, (m.byProject[l.project] ??= tally()), l.visible ? m.byVisibility.visible : m.byVisibility.hidden];
         for (const t of groups) {
@@ -102,6 +102,7 @@ export function measure(data, cache) {
         const c = cache.get(p.key);
         const cause = p.findings.length === 0 ? 'sans-constat' : c ? (c.manual ?? c.cause) : 'non-classe';
         m.byCause[cause]++;
+        (p.visible ? m.byVisibilityCause.visible : m.byVisibilityCause.hidden)[cause]++;
         (m.byProjectCause[p.project] ??= causes())[cause]++;
         if (c?.manual && cause !== 'sans-constat') {
             m.agreement.reviewed++;
@@ -208,6 +209,8 @@ export function serializeCache(cache) {
     return JSON.stringify(Object.fromEntries([...cache].sort(([a], [b]) => a.localeCompare(b))), null, 2) + '\n';
 }
 const pct = (a, b) => (b === 0 ? '—' : `${Math.round((100 * a) / b)} %`);
+/** Les causes qu'une meilleure spécification évite (critère de réussite de l'étape spec). */
+const SPEC_CAUSES = ['spec-floue', 'regle-inventee', 'test-manquant'];
 const row = (name, t) => `| ${name} | ${t.lots} | ${t.atLeast1} (${pct(t.atLeast1, t.lots)}) | ${t.atLeast2} (${pct(t.atLeast2, t.lots)}) | ${t.passes} |`;
 export function renderReport(m) {
     const all = [...CAUSES, 'sans-constat', 'non-classe'];
@@ -222,6 +225,12 @@ export function renderReport(m) {
         out.push(`| ${p} | ${used.map((c) => m.byProjectCause[p]?.[c] ?? 0).join(' | ')} | ${m.byProject[p].passes} |`);
     out.push('', '### Lots avec correction', '', '| Projet | Lots | ≥ 1 correction | ≥ 2 corrections | Passes |', '|---|---|---|---|---|', ...projects.map((p) => row(p, m.byProject[p])), row('**Total**', m.total), '');
     out.push('### Lots visibles et non visibles', '', '| Lots | Lots | ≥ 1 correction | ≥ 2 corrections | Passes |', '|---|---|---|---|---|', row('visibles', m.byVisibility.visible), row('non visibles', m.byVisibility.hidden), '');
+    out.push('### Par cause et par visibilité (passes)', '', `| Lots | Lots | Passes | ${used.map((c) => LABELS[c]).join(' | ')} | Spec floue, règle inventée ou test manquant |`, `|---|---|---|${used.map(() => '---').join('|')}|---|`);
+    for (const [name, t, byC] of [['visibles', m.byVisibility.visible, m.byVisibilityCause.visible], ['non visibles', m.byVisibility.hidden, m.byVisibilityCause.hidden]]) {
+        const spec = SPEC_CAUSES.reduce((n, c) => n + byC[c], 0);
+        out.push(`| ${name} | ${t.lots} | ${t.passes} | ${used.map((c) => byC[c]).join(' | ')} | ${spec} (${pct(spec, t.passes)}) |`);
+    }
+    out.push('');
     if (m.agreement.reviewed > 0)
         out.push(`Échantillon relu à la main : ${m.agreement.reviewed} passes, le modèle local est d'accord avec la relecture sur ${m.agreement.agree} (${pct(m.agreement.agree, m.agreement.reviewed)}) ; la cause relue prime dans les tableaux.`, '');
     return out.join('\n');

package/dist/orchestrate/accept.js

@@ -2,6 +2,7 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, posix } from 'node:path';
 import { parse } from 'yaml';
+import { citedRefs } from '../link.js';
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function git(repo, ...args) {
     return execFileSync('git', args, { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024 });
@@ -50,7 +51,7 @@ export function parseAcceptation(text) {
         return 'clé « vert » (booléen) attendue';
     const empreintes = isObj(doc.empreintes) ? Object.fromEntries(Object.entries(doc.empreintes).filter(([, v]) => typeof v === 'string')) : undefined;
     const resceaux = Array.isArray(doc.resceaux) ? doc.resceaux.filter((r) => isObj(r) && ['test', 'raison', 'date', 'avant', 'apres'].every((k) => typeof r[k] === 'string')) : undefined;
-    return { lot, fiche, fichiers: fichiers, vert, ...(empreintes ? { empreintes } : {}), ...(resceaux?.length ? { resceaux } : {}) };
+    return { lot, fiche, fichiers: fichiers, vert, ...(doc.e2e === true ? { e2e: true } : {}), ...(empreintes ? { empreintes } : {}), ...(resceaux?.length ? { resceaux } : {}) };
 }
 /** JSON à clés triées, sans la clé `vert` : la forme que le verrou compare. */
 const canon = (a) => JSON.stringify(Object.fromEntries(Object.entries(a).filter(([k]) => k !== 'vert').sort(([x], [y]) => x.localeCompare(y))));
@@ -122,16 +123,20 @@ export function sealAcceptation(repo, path) {
 }
 /**
  * Rescelle UN test (L200, `cadence spec reseal`, le lead — jamais une session) : le test d'un lot en cours contredit sa fiche et le verrou total
- * ne laisse aucun chemin de correction. La fiche reste inchangée depuis le commit rouge, les autres fichiers listés aussi : seule l'empreinte
- * du test nommé est refaite, la raison et les deux empreintes vont dans `resceaux`. Le commit (test + acceptation) est à faire : il devient le commit rouge.
+ * ne laisse aucun chemin de correction. Seule l'empreinte du test nommé est refaite (les autres fichiers listés restent inchangés), la raison et les deux
+ * empreintes vont dans `resceaux`. Le commit (test + acceptation) est à faire : il devient le commit rouge.
+ * La fiche est celle du commit rouge, ou (L217) une fiche amendée par des commits qui citent tous le lot (`refsOf` : `plan.refs`, lu comme `citedRefs` ;
+ * lot livré : le lot ou son `porteur`) et commitée : l'entrée porte alors `ficheAmendee`, le sha court du dernier commit qui l'a touchée.
  */
-export function resealAcceptation(repo, path, test, reason, today) {
+export function resealAcceptation(repo, path, test, reason, today, porteur, refsOf = () => []) {
     const file = join(repo, path);
     const a = parseAcceptation(readFileSync(file, 'utf8'));
     if (typeof a === 'string')
         throw new Error(`${path} : ${a}`);
     if (!reason.trim())
         throw new Error('--reason est obligatoire : la raison du rescellé va dans acceptation.json et en note du lot');
+    if (porteur && !a.vert)
+        throw new Error(`${path} n'est pas verte : un lot porteur (${porteur}) ne vaut que pour le test scellé d'un lot livré (vert: true)`);
     const norm = posix.normalize(test);
     const fichiers = a.fichiers.map((f) => posix.normalize(f));
     if (!fichiers.includes(norm))
@@ -144,8 +149,20 @@ export function resealAcceptation(repo, path, test, reason, today) {
         throw new Error(`${path} : pas de commit rouge lisible`);
     if (!existsSync(join(repo, norm)))
         throw new Error(`${norm} : fichier absent (un test supprimé ne se rescelle pas)`);
-    if (!gitOk(repo, 'diff', '--quiet', red, '--', a.fiche))
-        throw new Error(`la fiche ${a.fiche} a changé depuis le commit rouge ${red.slice(0, 7)} : le rescellé ne vaut que fiche inchangée (une fiche qui évolue passe par le lot et sa revue)`);
+    // Une fiche modifiée dans l'arbre de travail ou l'index n'est pas celle d'un commit du lot : elle se commite d'abord.
+    if (git(repo, 'status', '--porcelain', '--', a.fiche).trim() !== '')
+        throw new Error(`la fiche ${a.fiche} a des modifications non commitées : la commiter (en citant ${a.lot}) avant le rescellé`);
+    let ficheAmendee;
+    if (!gitOk(repo, 'diff', '--quiet', red, '--', a.fiche)) {
+        if (!existsSync(join(repo, a.fiche)))
+            throw new Error(`la fiche ${a.fiche} a été supprimée ou renommée depuis le commit rouge ${red.slice(0, 7)} : le rescellé ne vaut que pour une fiche présente`);
+        const citant = new Set([a.lot, ...(porteur ? [porteur] : [])]);
+        const commits = git(repo, 'log', '--format=%H%x1f%s%x1f%b%x1e', `${red}..HEAD`, '--', a.fiche).split('\x1e').map((r) => r.replace(/^\n/, '')).filter(Boolean).map((r) => { const [sha = '', subject = '', body = ''] = r.split('\x1f'); return { sha, day: '', subject, body: body.trim() }; });
+        const fautif = commits.find((c) => !citedRefs(c, refsOf).some((r) => citant.has(r.lot)));
+        if (fautif)
+            throw new Error(`la fiche ${a.fiche} a été modifiée depuis le commit rouge ${red.slice(0, 7)} par un commit qui ne cite pas ${a.lot} : ${fautif.sha.slice(0, 7)}`);
+        ficheAmendee = commits[0]?.sha.slice(0, 7);
+    }
     const touches = fichiers.filter((f) => f !== norm && (!gitOk(repo, 'diff', '--quiet', red, '--', f) || !existsSync(join(repo, f)) || a.empreintes?.[f] !== git(repo, 'hash-object', '--', f).trim()));
     if (touches.length)
         throw new Error(`autre(s) test(s) listé(s) modifié(s) depuis le commit rouge : ${touches.join(', ')} (le rescellé ne couvre que ${norm}, le verrou garde le reste)`);
@@ -155,9 +172,9 @@ export function resealAcceptation(repo, path, test, reason, today) {
     const doc = JSON.parse(readFileSync(file, 'utf8'));
     doc.empreintes[norm] = apres;
     const journal = Array.isArray(doc.resceaux) ? doc.resceaux : [];
-    doc.resceaux = [...journal, { test: norm, raison: reason.trim(), date: today, avant, apres }];
+    doc.resceaux = [...journal, { test: norm, raison: reason.trim(), date: today, avant, apres, ...(porteur ? { porteur } : {}), ...(ficheAmendee ? { ficheAmendee } : {}) }];
     writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`);
-    return { avant, apres, lot: a.lot };
+    return { avant, apres, lot: a.lot, ...(ficheAmendee ? { ficheAmendee } : {}) };
 }
 /** Pose `vert: true` dans le fichier (le cycle, jamais une session) ; le commit est à faire. */
 export function setVert(repo, path) {
@@ -379,7 +396,7 @@ export function acceptText(o) {
         isAcceptList(o.command)
             ? `The project declares several dedicated commands (\`orchestrate.accept\`, one per test runner), each of which runs ONLY the acceptance tests of this lot that sit under its root (the folder of its leading \`cd <folder> &&\`, else the repository): ${commands.map((x) => `\`${x}\` (root \`${acceptRoot(x) || '.'}\`)`).join(', ')}. Each is run from the repository root and gets \`CADENCE_ACCEPTATION\` (the absolute path of the lot's \`acceptation.json\`, also substituted for \`{acceptation}\`) and \`CADENCE_ACCEPTATION_ROOT\` (its root); it takes only the files listed under its root, a command with no listed file under its root is not run, and a listed file under no root is refused. Put each test file where its runner looks, and list every file in \`fichiers\`.${o.test ? ` The project's ordinary test command is \`${o.test}\`: it must stay green with your red tests committed.` : ''}`
             : `The project declares the dedicated command that runs ONLY the acceptance tests of this lot (\`orchestrate.accept\`): \`${commands[0]}\` (from the repository root; the program sets \`CADENCE_ACCEPTATION\` to the absolute path of the lot's \`acceptation.json\`, and replaces \`{acceptation}\` with it).${o.test ? ` The project's ordinary test command is \`${o.test}\`: it must stay green with your red tests committed.` : ''}`,
-        `Write \`${o.acceptation}\` (one file per lot, next to the sheet: another lot on the same ${screen ? 'screen' : 'subject'} has its own, which you never touch, nor its tests — give your test files names of your own): \`{ "lot": "<lot>", "fiche": "${o.fiche}", "fichiers": ["<test file>", …], "vert": false }\` (paths relative to the repository). The ordinary test config of the project (shared with its CI) must exclude those files while \`vert\` is false; the dedicated config includes only them. Both read the file with this runner template (copy it into the project, e.g. \`tests/acceptation-runner.mjs\`):`,
+        `Write \`${o.acceptation}\` (one file per lot, next to the sheet: another lot on the same ${screen ? 'screen' : 'subject'} has its own, which you never touch, nor its tests — give your test files names of your own): \`{ "lot": "<lot>", "fiche": "${o.fiche}", "fichiers": ["<test file>", …], "vert": false }\` (paths relative to the repository). If the tests need a build or a browser (Playwright, Chromium, \`dist\`), add \`"e2e": true\` to it: those files then stay out of the ordinary runner and the unit CI even once green (they would turn it red without \`dist\` or Chromium) and belong to the project's e2e suite, run after the build (\`acceptationE2e()\` of the runner template lists them). The ordinary test config of the project (shared with its CI) must exclude those files while \`vert\` is false; the dedicated config includes only them. Both read the file with this runner template (copy it into the project, e.g. \`tests/acceptation-runner.mjs\`):`,
     ];
     if (o.runner)
         lines.push('```js', o.runner.trimEnd(), '```');

package/dist/orchestrate/baseline.js

@@ -0,0 +1,66 @@
+// Ligne de base des tests (L213) : un lot n'est pas rendu « tests rouges » pour des échecs déjà présents au sha de départ.
+/* eslint-disable-next-line no-control-regex */
+const ANSI = /\u001b\[[0-9;]*m/g;
+/** Marqueurs d'échec des lanceurs courants : vitest/jest (FAIL, ●), pytest (FAILED, ERROR), go (--- FAIL:), TAP (not ok). */
+const MARKERS = [/^\s*FAIL(?:ED)?\s+(.+)$/, /^\s*ERROR\s+(\S+::.+)$/, /^\s*--- FAIL:\s+(\S+)/, /^\s*not ok\s+\d*\s*-?\s*(.+)$/, /^\s*●\s+(.+)$/];
+/** Identifiant pytest « chemin::test[param] » : coupe le message (« - assert … ») au premier « - » hors crochets. */
+function pytestId(s) {
+    if (!s.includes('::'))
+        return s;
+    let depth = 0;
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === '[')
+            depth++;
+        else if (s[i] === ']' && depth > 0)
+            depth--;
+        else if (depth === 0 && /\s/.test(s[i]) && /^\s+-(?:\s|$)/.test(s.slice(i)))
+            return s.slice(0, i);
+    }
+    return s;
+}
+/**
+ * vitest, fichier de test qui ne se charge pas : « FAIL  a.test.ts [ a.test.ts ] ». Seule une entrée de fichier porte le suffixe « [ chemin ] » (un test ou une suite contient toujours « > »).
+ * En espace de travail, le fichier est relatif à la racine du projet (précédé de « |projet| ») et les crochets à la racine du lancement : « FAIL  |pa|  src/a.test.ts [ packages/a/src/a.test.ts ] », donc pas de comparaison des deux.
+ * Le crochet doit finir par une extension : « FAIL\tgithub.com/x/y [build failed] » (go) n'est pas un fichier.
+ */
+const FILE_LOAD_FAIL = /^\s*FAIL\s+(?:\|[^|]*\|\s+)?[^>]+?\s+\[\s*[^\]]*\.\w+\s*\]\s*$/;
+const clean = (s) => pytestId(s)
+    .replace(/\s+-\s+(?:Assertion|\w*Error)\b.*$/, '') // pytest : « - AssertionError: … »
+    .replace(/\s*\(?\d+(?:\.\d+)?\s*m?s\)?\s*$/, '') // durée finale
+    .trim();
+/**
+ * Identifiants des tests en échec lus dans la sortie d'un lanceur (triés, sans doublon). Vide quand rien n'est identifiable :
+ * l'appelant ne peut alors rien comparer et garde les tests pour rouges.
+ */
+export function failedTests(output) {
+    const found = new Set();
+    for (const raw of output.replace(ANSI, '').split('\n')) {
+        if (FILE_LOAD_FAIL.test(raw))
+            continue; // échec sans nom (cf. hasUnnamedFailure), pas un test
+        for (const re of MARKERS) {
+            const m = re.exec(raw);
+            if (!m)
+                continue;
+            const name = clean(m[1]);
+            if (name && !/^(?:Test Files?|Tests?)\b/.test(name))
+                found.add(name);
+            break;
+        }
+    }
+    return [...found].sort();
+}
+/** Échecs d'après le lot qui n'étaient pas rouges au départ (`nouveaux`) et ceux qui l'étaient déjà (`existants`). */
+export function compareBaseline(now, base) {
+    const was = new Set(base);
+    return { nouveaux: now.filter((t) => !was.has(t)), existants: now.filter((t) => was.has(t)) };
+}
+/**
+ * Un échec que la sortie ne rattache à aucun test : erreur non gérée (vitest « Unhandled Errors », promesse rejetée), fichier de spec qui ne se charge plus (jest « Test suite failed to run », vitest « FAIL  a.test.ts [ a.test.ts ] » : le FAIL de fichier existait peut-être au départ), seuil de
+ * couverture non atteint. Comparer les seuls noms lus le masquerait derrière d'anciens échecs : l'appelant garde les tests pour rouges.
+ */
+export function hasUnnamedFailure(output) {
+    const text = output.replace(ANSI, '');
+    if (text.split('\n').some((l) => FILE_LOAD_FAIL.test(l)))
+        return true;
+    return /Unhandled (?:Errors?|Rejections?)|Test suite failed to run|caught \d+ unhandled|coverage threshold|Coverage for \w+ \([\d.]+%\) does not meet/i.test(text);
+}

package/dist/orchestrate/command.js

@@ -12,12 +12,13 @@ import { AGENTS_DIR } from '../skills.js';
 import { pidAlive, sharedStateDir } from '../state.js';
 import { acquireSlot, cadenceHome, freeSlots, liveSlots, liveWaves, registerWave, unregisterWave, updateWaveRepos } from './registry.js';
 import { loadTemplates, newsText, objective, renderBrief } from './briefs.js';
+import { readWaits, renderWaits } from './waits.js';
 import { acceptationFile, acceptText } from './accept.js';
 import { ficheReviewText } from './fiche.js';
 import { maquetteText } from './maquette.js';
-import { specText } from './spec.js';
+import { specScreen, specText } from './spec.js';
 import { candidates, parsePriority, parseUntil, readPriority, stopReason } from './continue.js';
-import { Budget, DROPPED, MAX_PASSES, briefName, countInterrupted, handBackDroppedQuestions, needsPrecheck } from './cycle.js';
+import { Budget, DROPPED, MAX_PASSES, MAX_PASSES_CONVERGING, briefName, countInterrupted, handBackDroppedQuestions, needsPrecheck } from './cycle.js';
 import { canInstallPrePush, installPrePush, removePrePush, snapshot } from './guard.js';
 import { buildArgs, buildLocalArgs, killSessions, mcpServersFor, readAgents, realClaude } from './launch.js';
 import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
@@ -34,8 +35,9 @@ export const DEFAULT_BUDGET = 2_000_000;
  * où il est passé, 250 lots, 11-10), rangé par estimate : jusqu'à 0,5 j p90 374 k (152 lots), de 0,5 à 1 j p90 732 k (88 lots, max
  * 1,09 M), au-delà d'un jour p90 1,14 M pour les 10 lots de 1,25 à 2 j (570 k par jour d'estimate), max 1,7 M (L188). Le plafond
  * de L78 (400 k par jour) rendait au lead, au deuxième tour, un lot de 1 j (L188 : 483 k puis 495 k).
+ * Plancher relevé de 450 k à 540 k (L218) avec la réserve de la passe fix (155 k) : 14 k + 282 k + 80 k + 155 k = 531 k arrondis, la marge avant refus du fix reste 385 k.
  */
-const LOT_BUDGET_FLOOR = 450_000;
+const LOT_BUDGET_FLOOR = 540_000;
 /** Lot de plus de 0,5 j et d'au plus 1 j : p90 mesuré du total, 732 k arrondis à 750 k. */
 const LOT_BUDGET_ONE_DAY = 750_000;
 /** Tokens par jour d'estimate au-delà d'un jour : p90 1,14 M pour 2 j. */
@@ -48,9 +50,10 @@ const LOT_BUDGET_PER_DAY = 570_000;
 const SCREEN_LOT_BUDGET = 1_300_000;
 /**
  * Allocation d'un lot à fiche `spec: true` (L188/L191), en plus du budget dérivé de l'estimate : sessions spec, fiche et accept hors de
- * l'estimate d'écriture. Aucun lot `spec:` seul n'a encore été mesuré ; 350 k est le pire cas mesuré des étapes d'un lot à écran (ol L113 : 349 k).
+ * l'estimate d'écriture. Relevée de 350 k à 450 k (L218) : la chaîne avant implement du lot spec warhammer L120 a coûté 388 k (350 k : pire cas
+ * mesuré des étapes d'un lot à écran, ol L113 : 349 k) ; cadence L217 n'en a pris que 176 k.
  */
-export const SPEC_STAGE_ALLOCATION = 350_000;
+export const SPEC_STAGE_ALLOCATION = 450_000;
 /** Base mesurée d'un budget, pour `--dry-run` : l'estimate (et l'étape spec) d'où il sort. */
 export function lotBudgetBasis(estimate, stage) {
     if (stage === 'screen' && lotBudget(estimate, stage) === SCREEN_LOT_BUDGET)
@@ -98,7 +101,7 @@ function lotArg(text) {
     return { project: m[1], lot: m[2], model: m[3] };
 }
 export function parseOrchestrateArgs(argv) {
-    const a = { lots: [], dryRun: false, watch: false, continue: false, answers: [], drop: [], stopAfterCurrent: false };
+    const a = { lots: [], dryRun: false, waits: false, watch: false, continue: false, answers: [], drop: [], stopAfterCurrent: false };
     const optional = (i) => (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-') && !LOT_LIKE.test(argv[i + 1]) ? argv[i + 1] : undefined);
     for (let i = 0; i < argv.length; i++) {
         const t = argv[i];
@@ -115,6 +118,13 @@ export function parseOrchestrateArgs(argv) {
                 i++;
             a[t === '--status' ? 'status' : 'resume'] = v ?? true;
         }
+        else if (t === '--waits')
+            a.waits = true;
+        else if (t === '--since') {
+            a.since = value(t);
+            if (!isDay(a.since))
+                throw new RafError(`--since invalide : ${a.since} (AAAA-MM-JJ)`);
+        }
         else if (t === '--watch')
             a.watch = true;
         else if (t === '--interval')
@@ -271,11 +281,12 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
             continue;
         }
         const small = lot.estimate <= 0.5 || lot.quickwin;
-        const state = newLot({ project: t.project, repo: t.repo, lot: t.lot, title: lot.title, visible: lot.visible, small, ...(lot.screen ? { screen: lot.screen } : {}), ...(lot.spec && !lot.screen ? { specLot: true } : {}), model: t.model, readOnlyPlan: plan.readonly });
+        const screen = specScreen(t.repo, env.config.spec.dir, lot);
+        const state = newLot({ project: t.project, repo: t.repo, lot: t.lot, title: lot.title, visible: lot.visible, small, ...(screen ? { screen } : {}), ...(lot.spec && !screen ? { specLot: true } : {}), model: t.model, readOnlyPlan: plan.readonly });
         if (neighbours.repos.length)
             state.repos = neighbours.repos;
         state.light = lot.estimate <= env.config.review.threshold;
-        state.budget = lotBudget(lot.estimate, lot.screen ? 'screen' : lot.spec ? 'spec' : undefined);
+        state.budget = lotBudget(lot.estimate, screen ? 'screen' : lot.spec ? 'spec' : undefined);
         state.dependsOn = lot.after.filter((d) => earlier.includes(d));
         if (node.kind === 'ok')
             state.node = { version: node.version, wanted: node.wanted, bin: node.bin, ...(node.skipped ? { skipped: node.skipped } : {}) };
@@ -342,7 +353,7 @@ function dryRun(lots, io, deps, budget, id) {
             steps.push({ kind: 'review', model: l.light ? light : full });
         }
         io.out(`  étapes : ${steps.map((s) => `${s.kind} (${s.model})`).join(' → ')}${l.small ? ' — petit lot' : ''}${l.light ? ` — revue légère (${light}, pas de passe des mineurs ; un bloquant ou un majeur → correction puis revue ${full})` : ''}${l.visible && !env.config.ux ? ' — UX à faire par le lead (orchestrate.ux absent)' : ''}`);
-        io.out(`  corrections : ${MAX_PASSES} passe(s) au plus, en session neuve`);
+        io.out(`  corrections : ${MAX_PASSES} passe(s) au plus (${MAX_PASSES_CONVERGING} si la revue converge), en session neuve`);
         io.out(l.light ? '  revue conforme avec mineurs : pas de passe des mineurs, ils sont rendus en notes' : '  revue conforme avec mineurs : une passe de correction des mineurs (session neuve), puis une revue courte ; les mineurs refusés sont rendus en « choix »');
         const pwDir = join(resolve(RunStore.runsDir(io.cwd)), id, lotSlug(l.project, l.lot), 'playwright');
         // brief écrit par --dry-run = base d'une délégation à la main : aucun dossier de vague (il n'existe pas)
@@ -377,18 +388,29 @@ function maxSessions(args, io) {
     const env = io.env.CADENCE_MAX_SESSIONS;
     return env ? parseMaxSessions(env, 'CADENCE_MAX_SESSIONS') : DEFAULT_MAX_SESSIONS;
 }
+/** Plafond à AFFICHER (`--status`, `lead tour`) : le réglage de l'humain, jamais 2 en dur. Un réglage invalide ne casse pas l'affichage (le lancement, lui, le refuse) : retour au défaut. */
+export function configuredCap(env, flag) {
+    if (flag !== undefined)
+        return flag;
+    try {
+        return env.CADENCE_MAX_SESSIONS ? parseMaxSessions(env.CADENCE_MAX_SESSIONS, 'CADENCE_MAX_SESSIONS') : DEFAULT_MAX_SESSIONS;
+    }
+    catch {
+        return DEFAULT_MAX_SESSIONS;
+    }
+}
 function duration(ms) {
     const s = Math.round(ms / 1000);
     return s < 60 ? `${s} s` : `${Math.floor(s / 60)} min ${String(s % 60).padStart(2, '0')} s`;
 }
 /** Vagues vivantes (toutes, quel que soit leur dossier de départ), créneaux libres et dépôts qu'elles tiennent. */
-export function liveLines() {
+export function liveLines(cap = DEFAULT_MAX_SESSIONS) {
     const home = cadenceHome();
     const waves = liveWaves(home);
     if (waves.length === 0)
         return [];
     const slots = liveSlots(home).length;
-    const lines = [`vagues en cours : ${waves.length} · sessions en cours : ${slots} · créneaux libres : ${freeSlots(waves, DEFAULT_MAX_SESSIONS)} sur ${DEFAULT_MAX_SESSIONS}`];
+    const lines = [`vagues en cours : ${waves.length} · sessions en cours : ${slots} · créneaux libres : ${freeSlots(waves, cap)} sur ${cap}`];
     for (const w of waves)
         lines.push(`  ${w.wave} (pid ${w.pid}, depuis ${w.started}) lancée depuis ${w.cwd} · plafond ${w.cap ?? '?'} · dépôts : ${w.repos.join(', ')}`);
     return lines;
@@ -397,9 +419,9 @@ export function liveLines() {
 const CLEAR_SCREEN = '\x1b[H\x1b[2J';
 const DEFAULT_WATCH_INTERVAL = 10;
 /** Ce que `--status` montre à un instant : les vagues vivantes, puis le tableau (absent si seules les vagues vivantes comptent). */
-function statusView(args, launch) {
+function statusView(args, launch, cap) {
     const store = typeof args.status === 'string' ? RunStore.find(launch, args.status) : RunStore.last(launch);
-    const live = liveLines();
+    const live = liveLines(cap);
     if (!store && live.length && args.status === true)
         return { live, running: true };
     if (!store)
@@ -433,10 +455,19 @@ export async function orchestrate(argv, io, deps) {
         throw new RafError('--status ne se combine pas avec --drop / --stop-after-current');
     if (args.resume !== undefined && args.stopAfterCurrent)
         throw new RafError('--resume ne se combine pas avec --stop-after-current (il reprend la vague, il ne l\'arrête pas)');
+    if (args.since !== undefined && !args.waits)
+        throw new RafError('--since s\'utilise avec --waits');
+    if (args.waits) {
+        if (args.lots.length || args.status !== undefined || args.resume !== undefined || args.watch || args.drop.length || args.stopAfterCurrent || args.continue || args.dryRun)
+            throw new RafError('--waits ne se combine avec aucune autre action');
+        for (const line of renderWaits(readWaits(launch, args.since)))
+            io.out(line);
+        return 0;
+    }
     if (args.status !== undefined) {
         maxSessions(args, io); // une valeur invalide est refusée ici aussi
         if (!args.watch) {
-            const { live, table } = statusView(args, launch);
+            const { live, table } = statusView(args, launch, configuredCap(io.env, args.maxSessions));
             for (const line of live)
                 io.out(line);
             if (!table)
@@ -450,7 +481,7 @@ export async function orchestrate(argv, io, deps) {
         // --watch : le même tableau, rafraîchi ; il s'arrête seul quand plus aucune vague ne tourne (le dernier rendu reste affiché)
         const sleep = deps.watchSleep ?? ((ms) => new Promise((res) => setTimeout(res, ms)));
         for (;;) {
-            const { live, table, running } = statusView(args, launch);
+            const { live, table, running } = statusView(args, launch, configuredCap(io.env, args.maxSessions));
             io.out(CLEAR_SCREEN);
             for (const line of live)
                 io.out(line);
@@ -472,7 +503,7 @@ export async function orchestrate(argv, io, deps) {
     if (args.drop.length || args.stopAfterCurrent)
         return control(args, io);
     if (args.lots.length === 0 && !args.continue)
-        throw new RafError('usage : cadence orchestrate <projet>:<lot>… [--budget 2M] [--max-sessions 2] [--dry-run] [--continue [--until 18:00] [--priority a,b]] | --status [vague] [--watch [--interval 10]] | --resume [vague] [--answer projet:lot "réponse"] | --drop projet:lot | --stop-after-current');
+        throw new RafError('usage : cadence orchestrate <projet>:<lot>… [--budget 2M] [--max-sessions 2] [--dry-run] [--continue [--until 18:00] [--priority a,b]] | --waits [--since AAAA-MM-JJ] | --status [vague] [--watch [--interval 10]] | --resume [vague] [--answer projet:lot "réponse"] | --drop projet:lot | --stop-after-current');
     const refusals = [];
     const targets = resolveTargets(args, io, refusals);
     const pre = await preflight(args, targets, io, deps, launch);
@@ -785,8 +816,8 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         const free = await acquireSlot(home, cap, {
             wave: wave.id,
             pollMs: deps.slotPollMs,
-            onWait: (h, ms) => wctx.log(`en attente d'un créneau de session depuis ${duration(ms)} (${h.length}/${cap} en cours : ${[...new Set(h.map((x) => x.wave))].join(', ')})`),
-            onGot: (ms) => wctx.log(`créneau de session obtenu après ${duration(ms)} d'attente`),
+            onWait: (h, ms) => wctx.log(`${o.lot ? `${o.lot} · ` : ''}en attente d'un créneau de session depuis ${duration(ms)} (${h.length}/${cap} en cours : ${[...new Set(h.map((x) => x.wave))].join(', ')})`),
+            onGot: (ms) => wctx.log(`${o.lot ? `${o.lot} · ` : ''}créneau de session obtenu après ${duration(ms)} d'attente`),
         });
         try {
             return await deps.claude(args, o);

package/dist/orchestrate/continue.js

@@ -6,7 +6,8 @@ import { planLoader } from '../config.js';
 import { gitRoot } from '../git.js';
 import { findProjects, isProject } from '../lead.js';
 import { RafError } from '../plan.js';
-import { lotBudget } from './command.js';
+import { lotBudget, projectEnv } from './command.js';
+import { specScreen } from './spec.js';
 import { STOP_REQUESTED } from './cycle.js';
 /** `--until 18:00` : l'heure d'aujourd'hui (date de `now`) à partir de laquelle la vague ne tire plus de lot. */
 export function parseUntil(text, now) {
@@ -71,8 +72,15 @@ export function candidates(launch, o) {
         catch {
             continue;
         }
+        let specDir = 'docs/specs';
+        try {
+            specDir = projectEnv(dir).config.spec.dir;
+        }
+        catch {
+            // configuration illisible : le dossier par défaut
+        }
         for (const lot of ready) {
-            if (o.exclude.has(`${project}:${lot.id}`) || decisionPending(lot) || lotBudget(lot.estimate, lot.screen ? 'screen' : lot.spec ? 'spec' : undefined) > o.remaining)
+            if (o.exclude.has(`${project}:${lot.id}`) || decisionPending(lot) || lotBudget(lot.estimate, specScreen(dir, specDir, lot) ? 'screen' : lot.spec ? 'spec' : undefined) > o.remaining)
                 continue;
             out.push({ project, dir, lot });
         }