@sylad/cadence 1.1.0 → 1.3.0

package/dist/orchestrate/accept.js

@@ -49,7 +49,8 @@ export function parseAcceptation(text) {
     if (typeof vert !== 'boolean')
         return 'clé « vert » (booléen) attendue';
     const empreintes = isObj(doc.empreintes) ? Object.fromEntries(Object.entries(doc.empreintes).filter(([, v]) => typeof v === 'string')) : undefined;
-    return { lot, fiche, fichiers: fichiers, vert, ...(empreintes ? { empreintes } : {}) };
+    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, ...(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))));
@@ -81,6 +82,22 @@ export function redSha(repo, path) {
     }
     return null;
 }
+/**
+ * Le commit rouge a bougé depuis `anchor` par un rescellé du lead (`cadence spec reseal`, L200) : le nouveau sha, sinon null.
+ * Seul un commit qui a allongé le journal `resceaux` ET qu'aucune session de la vague n'a fait (`bySession`) est adopté ; toute autre réécriture reste un écart pour le verrou.
+ */
+export function resealedRouge(repo, path, anchor, bySession = () => false) {
+    const now = redSha(repo, path);
+    if (!now || now === anchor)
+        return null;
+    if (bySession(now))
+        return null; // un commit de session n'est jamais un rescellé du lead : il reste un écart pour le verrou
+    const journal = (rev) => {
+        const r = show(repo, rev, path)?.resceaux;
+        return Array.isArray(r) ? r.length : 0;
+    };
+    return journal(now) > journal(anchor) ? now : null;
+}
 /** Chemin (relatif au dépôt) de l'`acceptation.json` du lot sous `dir`, ou null. */
 export function findAcceptation(repo, dir, lot) {
     for (const path of listAcceptations(repo, dir).sort()) {
@@ -103,6 +120,47 @@ export function sealAcceptation(repo, path) {
     doc.empreintes = Object.fromEntries(fichiers.map((f) => [f, git(repo, 'hash-object', '--', f).trim()]));
     writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`);
 }
+/**
+ * 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.
+ */
+export function resealAcceptation(repo, path, test, reason, today, porteur) {
+    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))
+        throw new Error(`${test} n'est pas listé dans ${path} (fichiers : ${fichiers.join(', ')})`);
+    const avant = a.empreintes?.[norm];
+    if (!a.empreintes || !avant)
+        throw new Error(`${path} n'est pas scellée (pas d'empreinte pour ${norm}) : l'étape accept n'est pas finie, rien à resceller`);
+    const red = redSha(repo, path);
+    if (!red)
+        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)`);
+    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)`);
+    const apres = git(repo, 'hash-object', '--', norm).trim();
+    if (apres === avant)
+        throw new Error(`${norm} est inchangé depuis le scellé : rien à resceller`);
+    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, ...(porteur ? { porteur } : {}) }];
+    writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`);
+    return { avant, apres, lot: a.lot };
+}
 /** Pose `vert: true` dans le fichier (le cycle, jamais une session) ; le commit est à faire. */
 export function setVert(repo, path) {
     const file = join(repo, path);
@@ -288,12 +346,42 @@ export function lockViolations(repo, dir, headBefore, opts = {}) {
     }
     return out;
 }
+/** Une liste (même d'un seul élément) lance chaque entrée sous sa racine ; une chaîne garde le dépôt pour racine. Le brief et le cycle décident par cette seule fonction. */
+export function isAcceptList(accept) {
+    return Array.isArray(accept);
+}
+/** Commandes de `orchestrate.accept` : une chaîne ou une liste (L189), toujours rendue en liste. */
+export function acceptCommands(accept) {
+    return accept === undefined ? [] : isAcceptList(accept) ? accept : [accept];
+}
+/** Racine d'une commande : le dossier de son `cd <dossier> &&` initial (relatif au dépôt, normalisé), sinon le dépôt (''). Un `cd` qui sort du dépôt n'est pas une racine. */
+export function acceptRoot(command) {
+    const m = /^\s*cd\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*&&/.exec(command);
+    const dir = posix.normalize(m?.[1] ?? m?.[2] ?? m?.[3] ?? '.');
+    return dir === '.' || dir === '..' || dir.startsWith('../') || posix.isAbsolute(dir) ? '' : dir.replace(/\/$/, '');
+}
+/** Le fichier est sous la racine (le dépôt, '', contient tout). */
+export const underRoot = (file, root) => {
+    const f = posix.normalize(file);
+    return root === '' || f.startsWith(`${root}/`);
+};
+/** Lancements d'une liste de commandes (`single` : la chaîne seule de `orchestrate.accept`, dont la racine reste le dépôt, `cd` ou non, comme avant la liste) pour les fichiers de l'acceptation : une commande sans fichier sous sa racine n'est pas lancée ; un fichier sous aucune racine est un orphelin. */
+export function planAcceptRuns(commands, fichiers, single = false) {
+    const all = commands.map((command) => ({ command, root: single ? '' : acceptRoot(command) }));
+    return { runs: all.filter((r) => fichiers.some((f) => underRoot(f, r.root))), orphans: fichiers.filter((f) => !all.some((r) => underRoot(f, r.root))) };
+}
 /** Consigne propre à l'étape accept dans le brief : fiche, maquette, commande dédiée, gabarit du lanceur, et les écarts de la passe précédente. */
 export function acceptText(o) {
+    const commands = acceptCommands(o.command);
+    const screen = o.screen !== false;
     const lines = [
-        `Sheet: \`${o.fiche}\` (rules, fields, actions). Mockup: \`${o.maquette}\` (every field carries \`data-testid="<field id>"\`). You get nothing else about the screen: the implementation does not exist yet.`,
-        `The project declares the dedicated command that runs ONLY the acceptance tests of this lot (\`orchestrate.accept\`): \`${o.command}\` (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 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\`):`,
+        !screen
+            ? `Sheet: \`${o.fiche}\` (cases, rules, contracts, data). You get nothing else about the behaviour: the implementation does not exist yet.`
+            : `Sheet: \`${o.fiche}\` (rules, fields, actions). Mockup: \`${o.maquette}\` (every field carries \`data-testid="<field id>"\`). You get nothing else about the screen: the implementation does not exist yet.${o.back ? ' The sheet also has a back part (`cas`, `contrats`, `donnees`): write the cases of its rules too, calling the contracts of `contrats[]` as close as possible and simulating the external sources from `entree`.' : ''}`,
+        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). 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/aval.js

@@ -1,30 +1,46 @@
 import { posix } from 'node:path';
 import { LARGEURS } from '../spec.js';
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-/** Une ligne par règle de la fiche : id, [état, statut], énoncé, message exact, tests prévus. Vide quand le document n'est pas une fiche. */
+/** Une ligne par règle de la fiche : id, [état ou cas, statut], énoncé, message exact, tests prévus. Vide quand le document n'est pas une fiche. */
 export function ficheRules(doc) {
     if (!isObj(doc) || !Array.isArray(doc.regles))
         return [];
     return doc.regles.filter(isObj).map((r) => {
         const message = typeof r.message === 'string' ? ` Message: « ${r.message} ».` : '';
         const tests = Array.isArray(r.tests) ? ` Tests: ${r.tests.map((t) => `« ${String(t)} »`).join(', ')}.` : '';
-        return `- ${String(r.id)} [${String(r.etat)}, ${String(r.statut)}] ${String(r.enonce ?? '').trim()}${message}${tests}`;
+        const where = typeof r.etat === 'string' ? r.etat : Array.isArray(r.cas) ? r.cas.join(', ') : '';
+        return `- ${String(r.id)} [${where ? `${where}, ` : ''}${String(r.statut)}] ${String(r.enonce ?? '').trim()}${message}${tests}`;
     });
 }
+/** Une ligne par contrat de la fiche back : id, appel, entrée, sortie, erreurs (code et message exact). Vide sans contrats. */
+export function ficheContracts(doc) {
+    if (!isObj(doc) || !Array.isArray(doc.contrats))
+        return [];
+    return doc.contrats.filter(isObj).map((c) => {
+        const erreurs = Array.isArray(c.erreurs) && c.erreurs.length ? ` Errors: ${c.erreurs.filter(isObj).map((e) => `${String(e.code)} « ${String(e.message)} »`).join(', ')}.` : '';
+        return `- ${String(c.id)} ${String(c.appel)} — input: ${String(c.entree ?? '').trim()}; output: ${String(c.sortie ?? '').trim()}.${erreurs}`;
+    });
+}
+/** Le document a-t-il une partie écran (`ecran`) ? Une fiche back seule n'en a pas : ni maquette, ni captures. */
+export const hasScreenPart = (doc) => isObj(doc) && isObj(doc.ecran);
 /** Consigne de la fiche pour une étape en aval : `{{fiche}}` des gabarits implement, fix, review et ux. */
 export function avalFicheText(kind, o) {
     const folder = posix.dirname(o.fiche);
     const maquette = `${folder}/maquette.html`;
-    const head = `This lot has a screen sheet: \`${o.fiche}\` (mockup \`${maquette}\`). It is the reference of the screen; its rules are:\n${o.rules.join('\n')}`;
+    const screen = o.screen !== false;
+    const contracts = o.contracts?.length ? `\nIts contracts (the calls the code must hold, with the exact codes and messages of their errors) are:\n${o.contracts.join('\n')}` : '';
+    const head = screen
+        ? `This lot has a screen sheet: \`${o.fiche}\` (mockup \`${maquette}\`). It is the reference of the screen; its rules are:\n${o.rules.join('\n')}${contracts}`
+        : `This lot has a spec sheet: \`${o.fiche}\` (no screen: use cases, rules, contracts and data). It is the reference of the behaviour; its rules are:\n${o.rules.join('\n')}${contracts}`;
     if (kind === 'implement' || kind === 'fix') {
         return [
             head,
-            kind === 'implement' ? 'Read the sheet and the mockup before the first test.' : 'The sheet stays the reference of the fix: a finding that contradicts it is contested under "choix" with the rule.',
+            kind === 'implement' ? `Read the sheet${screen ? ' and the mockup' : ''} before the first test.` : 'The sheet stays the reference of the fix: a finding that contradicts it is contested under "choix" with the rule.',
             o.acceptation
                 ? `The acceptance tests are already written and committed red, from the sheet (files listed in \`${o.acceptation}\`): make them green without modifying them — the program compares them to the red commit, and a modified file hands the lot back. A change one of them needs is a question or a finding, never a silent edit.`
                 : '',
             'The tests you write yourself cite the rule they cover in their name (`R2 — …`); do not invent a rule: a case the sheet does not cover is noted in your report (under "nonVerifie" or "choix"), not coded.',
-            kind === 'implement' ? 'The News entry ends with a `## Hypothèses` section: one line per rule whose status is `hypothese` (`- R3 — what the screen does, and what changes if it is wrong`, taken from its `si_faux`); leave it out when the sheet has no hypothesis.' : '',
+            kind === 'implement' && screen ? 'The News entry ends with a `## Hypothèses` section: one line per rule whose status is `hypothese` (`- R3 — what the screen does, and what changes if it is wrong`, taken from its `si_faux`); leave it out when the sheet has no hypothesis.' : '',
         ]
             .filter(Boolean)
             .join('\n');
@@ -36,8 +52,11 @@ export function avalFicheText(kind, o) {
             o.acceptation
                 ? `The acceptance tests are listed in \`${o.acceptation}\`${o.rouge ? ` and were committed red at ${o.rouge.slice(0, 7)}` : ''}: each file must be unchanged since the red commit (\`git diff ${o.rouge ? o.rouge.slice(0, 7) : '<red commit>'} -- <file>\` is empty).`
                 : 'No acceptance tests were written for this lot: the tests of the rules are the ones the implementation wrote, named after the rule (`R2 — …`).',
+            o.contracts?.length ? 'Check each contract too: the code returns the output of the sheet and the exact codes and messages of its errors, and every datum the sheet announces without modification (`donnees`, `modification: aucune`) is intact. A contract that departs from the sheet is a major finding.' : '',
             'A rule without a test, an acceptance test modified since the red commit, a rule coded that is not in the sheet, and a test that is green without exercising its rule are major findings (name the rule and the file).',
-        ].join('\n');
+        ]
+            .filter(Boolean)
+            .join('\n');
     }
     return [
         `This lot has a screen sheet (\`${o.fiche}\`) and a mockup (\`${maquette}\`) that was already reviewed: this pass is a conformity pass, not the full audit. Compare the running app to the mockup, state by state (the states of the sheet), at ${LARGEURS.join(' and ')} px, against the captures \`${folder}/maquette-<état>-<largeur>.png\`.`,

package/dist/orchestrate/briefs.js

@@ -42,6 +42,9 @@ export function capturesText(captureDir) {
 const FILES = {
     precheck: 'precheck.md',
     spec: 'spec.md',
+    'spec-back': 'spec-back.md',
+    'accept-back': 'accept-back.md',
+    fiche: 'fiche.md',
     accept: 'accept.md',
     maquette: 'maquette.md',
     implement: 'implement.md',

package/dist/orchestrate/command.js

@@ -12,11 +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, 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';
@@ -28,18 +30,45 @@ import { linkNodeBin, nvmVersionsDir, resolveNode } from './node-env.js';
 import { quotaText, renderTable } from './table.js';
 import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveModulesDir, snapshotExists, waveReadsControl, withoutLaunchVars, spawnReexec, takeSnapshot, toolDirOf } from './snapshot.js';
 export const DEFAULT_BUDGET = 2_000_000;
-/** Tokens comptés par jour d'estimate (L78) ; mesuré le 06-10 : des lots de 0,5 j ont mangé 192 à 531 k, des lots de 1 j 455 à 468 k (2 M pour 6 lots). Depuis le plancher de L128 (450 k), ce plafond ne borne plus que les lots de plus de 1,125 j : les 5 lots du 06-10 passent tous. */
-const LOT_BUDGET_PER_DAY = 400_000;
 /**
- * Plancher (L128) : de quoi payer, dans le pire cas mesuré, une écriture, sa revue, une passe de correction et la revue
- * courte qui la suit (65 k, cf. REVIEW_RESERVE). Mesures de tous les `.cadence/runs/*` : passes fix médiane 45 k, p90 63 k,
- * max 112 k ; passes implement médiane 60 k, p90 93 k, max 282 k (L62). Pire cas : L62, 14 k de contrôle + 282 k d'écriture
- * + 80 k de revue = 376 k, plus 65 k de réserve = 441 k < 450 k, la passe fix part. Corrige L126 (200 k, rendu à la 2e passe) ;
- * L62 (estimate 1,5, donc 600 k) n'est pas changé par le plancher, la réserve de L145 couvre déjà sa correction et sa revue.
+ * Budget d'un lot ordinaire (L78, L128, recalibré L194). Mesuré sur le TOTAL de chaque lot dans `.cadence/runs` (toutes les vagues
+ * 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).
  */
 const LOT_BUDGET_FLOOR = 450_000;
-/** Budget d'un lot, dérivé de son estimate : empêche quelques lots d'avaler le budget de la vague au détriment des autres. */
-export const lotBudget = (estimate) => Math.max(LOT_BUDGET_FLOOR, Math.round(estimate * LOT_BUDGET_PER_DAY));
+/** 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. */
+const LOT_BUDGET_PER_DAY = 570_000;
+/**
+ * Total d'un lot à `screen:` (L194), étapes spec, maquette et accept comprises : p90 1,28 M sur 5 lots (L113 1,12 M, L25 1,28 M, L50 877 k,
+ * L85 758 k, L43 238 k), arrondi à 1,3 M. Remplace l'allocation de L191 (+350 k au budget d'estimate), qui ne payait ni l'UX de
+ * conformité ni les passes de correction.
+ */
+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).
+ */
+export const SPEC_STAGE_ALLOCATION = 350_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)
+        return "p90 mesuré du total d'un lot à écran, étapes spec, maquette et accept comprises";
+    const ordinary = lotBudget(estimate);
+    const basis = estimate <= 0.5 ? "plancher d'un lot jusqu'à 0,5 j" : estimate <= 1 ? "p90 mesuré du total d'un lot de 0,5 à 1 j" : Math.round(estimate * LOT_BUDGET_PER_DAY) <= LOT_BUDGET_ONE_DAY ? `plancher de ${LOT_BUDGET_ONE_DAY} au-delà d'un jour, l'estimate × ${LOT_BUDGET_PER_DAY} ne le dépasse pas encore` : `${LOT_BUDGET_PER_DAY} par jour, p90 mesuré du total au-delà d'un jour`;
+    if (!stage)
+        return basis;
+    return `${ordinary} dérivés de l'estimate (${basis}), plus ${SPEC_STAGE_ALLOCATION} pour les étapes spec, ${stage === 'screen' ? 'maquette' : 'fiche'} et accept`;
+}
+/** Budget d'un lot, dérivé de son estimate et de sa catégorie : empêche quelques lots d'avaler le budget de la vague au détriment des autres. Un lot à `screen:` vaut le total mesuré d'un lot à écran (L194) ; un lot à `spec: true` y ajoute l'allocation de son étape (L191). */
+export const lotBudget = (estimate, stage) => {
+    const ordinary = estimate <= 0.5 ? LOT_BUDGET_FLOOR : Math.max(LOT_BUDGET_ONE_DAY, Math.round(estimate * LOT_BUDGET_PER_DAY));
+    if (stage === 'screen')
+        return Math.max(SCREEN_LOT_BUDGET, ordinary + SPEC_STAGE_ALLOCATION);
+    return ordinary + (stage === 'spec' ? SPEC_STAGE_ALLOCATION : 0);
+};
 /** Sessions simultanées, toutes vagues confondues (`--max-sessions`, ou CADENCE_MAX_SESSIONS). */
 export const DEFAULT_MAX_SESSIONS = 2;
 /** `1500000`, `1.5M`, `800k`. */
@@ -58,11 +87,11 @@ export function parseMaxSessions(text, what = '--max-sessions') {
     return Number(text);
 }
 // une vague (2026-10-04-1412) n'a ni « : » ni « / » : leur présence désigne un lot, quel que soit son motif (R-M7/ux-1)
-const LOT_LIKE = /^(?:[\w.-]+:[\w.-][\w./-]*|[\w.-]+\/[\w./-]*|[A-Za-z]+\d+)(?:@\w+)?$/;
+const LOT_LIKE = /^(?:[\w.-]+(?:\/[\w.-]+)*:[\w.-][\w./-]*|[\w.-]+\/[\w./-]*|[A-Za-z]+\d+)(?:@\w+)?$/;
 const MODELS = ['sonnet', 'opus', 'haiku'];
 function lotArg(text) {
-    // le premier « : » sépare le projet du lot, un « @ » final le modèle ; le lot garde ses « / » (L120)
-    const m = /^(?:([\w.-]+):)?([\w.-][\w./-]*?)(?:@(\w+))?$/.exec(text);
+    // le premier « : » sépare le projet du lot, un « @ » final le modèle ; le lot garde ses « / » (L120), le projet peut être un chemin depuis le dossier (`groupe/gamma`, projet imbriqué de lead tour --depth, L201)
+    const m = /^(?:([\w.-]+(?:\/[\w.-]+)*):)?([\w.-][\w./-]*?)(?:@(\w+))?$/.exec(text);
     if (!m)
         throw new RafError(`lot invalide : ${text} (projet:lot, lot, projet:lot@haiku)`);
     if (m[3] && !MODELS.includes(m[3]))
@@ -70,7 +99,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];
@@ -87,6 +116,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')
@@ -243,11 +279,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 } : {}), 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);
+        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 } : {}) };
@@ -284,7 +321,7 @@ function dryRun(lots, io, deps, budget, id) {
         const lot = env.loadPlan().lot(l.lot);
         const slot = repos.indexOf(l.repo);
         io.out(`${lotKey(l.project, l.lot)} — ${l.title}`);
-        io.out(`  budget du lot : ${l.budget} tokens comptés (dérivé de l'estimate)`);
+        io.out(`  budget du lot : ${l.budget} tokens comptés (base : ${lotBudgetBasis(lot.estimate, l.screen ? 'screen' : l.specLot ? 'spec' : undefined)})`);
         io.out(`  file ${basename(l.repo)} · ${slot < 2 ? `créneau ${slot + 1}` : 'en attente d\'un créneau'}`);
         if (l.repos?.length)
             io.out(`  dépôts voisins : ${l.repos.map((r) => r.rel).join(', ')} (verrou, garde de push et --add-dir ; leurs commits citent ${l.lot})`);
@@ -294,11 +331,14 @@ function dryRun(lots, io, deps, budget, id) {
             io.out(`  node : ${l.node.version} (.nvmrc ${l.node.wanted}${skipped})`);
         }
         const steps = [{ kind: 'implement', model: l.model }];
-        if (l.screen && env.config.accept)
+        const specStage = !!(l.screen || l.specLot);
+        if (specStage && env.config.accept)
             steps.unshift({ kind: 'accept', model: 'sonnet' });
         if (l.screen && env.config.maquette)
             steps.unshift({ kind: 'maquette', model: env.config.review.full });
-        if (l.screen)
+        if (l.specLot && env.config.fiche)
+            steps.unshift({ kind: 'fiche', model: 'sonnet' });
+        if (specStage)
             steps.unshift({ kind: 'spec', model: 'sonnet' });
         if (needsPrecheck(env.config, env.loadPlan(), l.repo, l.lot, l.repos))
             steps.unshift({ kind: 'precheck', model: env.config.precheckLocal ? 'local' : 'sonnet' });
@@ -311,29 +351,31 @@ 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)
         const vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', ux: '', choix: '', checks: '', news: l.visible ? newsText(l.lot) : '', captures: '' };
-        if (l.screen)
-            vars.spec = specText({ dir: env.config.spec.dir, render: env.config.spec.render, screen: l.screen });
+        if (specStage)
+            vars.spec = specText({ dir: env.config.spec.dir, render: env.config.spec.render, screen: l.screen, back: !!l.specLot });
         if (l.screen && env.config.maquette)
             vars.maquette = maquetteText({ fiche: `${env.config.spec.dir}/<écran>/fiche.yaml`, passes: 0 });
-        if (l.screen && env.config.accept) {
-            const folder = `${env.config.spec.dir}/<écran>`;
-            vars.accept = acceptText({ fiche: `${folder}/fiche.yaml`, maquette: `${folder}/maquette.html`, acceptation: acceptationFile(`${folder}/fiche.yaml`, l.lot), command: env.config.accept, test: env.config.test });
+        if (l.specLot && env.config.fiche)
+            vars.fiche = ficheReviewText({ fiche: `${env.config.spec.dir}/<sujet>/fiche.yaml`, passes: 0 });
+        if (specStage && env.config.accept) {
+            const folder = `${env.config.spec.dir}/${l.screen ? '<écran>' : '<sujet>'}`;
+            vars.accept = acceptText({ fiche: `${folder}/fiche.yaml`, maquette: `${folder}/maquette.html`, screen: !!l.screen, back: false, acceptation: acceptationFile(`${folder}/fiche.yaml`, l.lot), command: env.config.accept ?? '', test: env.config.test });
         }
         for (const s of steps) {
             const file = join(tmp, `${lotSlug(l.project, l.lot)}--${s.kind}.md`);
-            const brief = renderBrief(s.kind, vars, deps.templatesDir);
+            const brief = renderBrief(briefName(l, s.kind), s.kind === 'fiche' || vars.fiche === undefined ? vars : { ...vars, fiche: '' }, deps.templatesDir); // la consigne de revue de fiche ne sert qu'au brief de la fiche : implement et review en sont la base d'une délégation à la main
             writeFileSync(file, brief);
-            const playwright = !!mcpServersFor(s.kind, l.visible, '', l.small).playwright;
+            const playwright = !!mcpServersFor(s.kind, l.visible, '', l.small, !!l.screen).playwright;
             const local = s.model === 'local';
             const args = (local ? buildLocalArgs : buildArgs)({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model === 'local' ? 'sonnet' : s.model, local, effort: env.config.effort[s.kind === 'review-small' ? 'review' : s.kind], schema: schemaFor(s.kind), agent: s.kind === 'implement' ? undefined : s.kind === 'spec' ? 'spec-writer' : s.kind === 'accept' ? 'acceptance-writer' : s.kind === 'ux' || s.kind === 'maquette' ? 'ux-reviewer' : s.kind === 'precheck' ? 'precheck-reader' : 'code-reviewer', cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && (s.kind === 'implement' || s.kind === 'spec') ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
             io.out(`  ${s.kind} : ${local ? 'claude-local' : 'claude'} ${args.join(' ')}`);
             io.out(`    brief : ${file}`);
-            const servers = Object.keys(mcpServersFor(s.kind, l.visible, '', l.small));
+            const servers = Object.keys(mcpServersFor(s.kind, l.visible, '', l.small, !!l.screen));
             io.out(`    mcp : ${servers.length ? `${servers.join(', ')} (captures dans le dossier de la vague : <vague>/${lotSlug(l.project, l.lot)}/playwright)` : 'aucun'}`);
         }
     }
@@ -344,18 +386,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;
@@ -364,9 +417,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)
@@ -400,10 +453,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)
@@ -417,7 +479,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);
@@ -439,7 +501,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);
@@ -752,8 +814,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) > 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 });
         }