@sylad/cadence 1.3.0 → 1.5.1

package/dist/cli.js

@@ -4,7 +4,7 @@ import { basename, dirname, join, posix, relative, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
 import { readDocsConfig, readHookConfig, readNewsConfig, readOrchestrateConfig, readPlanConfig, readSessionConfig } from './config.js';
 import { repoSections, repoShas, resolveLotRepos } from './repos.js';
-import { audit, exemptPlanOnly, hypothesesOf, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
+import { audit, exemptPlanOnly, gateProgress, gateText, gateWaiting, hypothesesOf, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
 import { short } from './check.js';
 import { isDay, toDay } from './dates.js';
 import { deliver, parseDeliverConfig, realDeps } from './deliver.js';
@@ -36,6 +36,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf screen <id> page|component|journey|none   pose, remplace ou retire screen: d'un lot visible existant (seule la valeur page adopte l'étape spec d'orchestrate)
   raf spec <id> on|off   pose ou retire spec: d'un lot existant (le lot change un comportement : étape spec back d'orchestrate)
   raf start <id>        raf done <id> [--force]        raf drop <id> [--reason texte]
+  raf todo <id> [--reason texte]   remet en attente un lot démarré sans commit de travail (doing → todo, started retiré, note datée) ; refusé s'il a des commits
   raf note <id> "texte"
   raf did <id> ["texte"]   un lot récurrent (--every) a été refait : le « dû depuis N j » repart de aujourd'hui
   raf ux enable         revue UX obligatoire avant « done » pour les lots --visible
@@ -50,9 +51,9 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf ignore <sha> | "<sujet exact>" [--reason texte]   acquitte un commit sans lot (ou citant un id inconnu) sans réécrire l'historique ; raf check --ignored les liste
   raf gantt [-o docs/plan/gantt.html]
   raf hook install      (pre-commit et post-commit ; cadence.yaml hook.autostart: warn|refuse|start)
-  cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--dry-run] [--wave nom] [--continue [--until HH:MM] [--priority a,b]]   une session claude neuve par étape ; --status [vague] [--watch [--interval s]] ; --resume [vague] [--budget 1M] [--answer projet:lot "réponse"] [--drop projet:lot] ; --drop projet:lot [--wave vague] ; --stop-after-current [--wave vague] ; --waits [--since AAAA-MM-JJ]
+  cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--dry-run] [--wave nom] [--continue [--until HH:MM] [--priority a,b]]   une session claude neuve par étape ; --status [vague] [--watch [--interval s]] ; --resume [vague] [--budget 1M] [--budget projet:lot=+300k] [--answer projet:lot "réponse"] [--drop projet:lot] ; --drop projet:lot [--wave vague] ; --stop-after-current [--wave vague] ; --waits [--since AAAA-MM-JJ]
   cadence lead tour [dossier] [--idle 3] [--depth n] [--json]   le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan, ou la ligne du dossier seul s'il est lui-même un projet (en cours, dérive, notes de clôture, prochain lot prêt, dépôt)
-  cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--json]   mesure des passes de correction des journaux dossier/.cadence/runs : lots à ≥1 et ≥2 corrections, par projet, visibles ou non, passes par cause (classées par Ollama avec --classify, hors quota)
+  cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--since date] [--json]   mesure des passes de correction des journaux dossier/.cadence/runs : lots à ≥1 et ≥2 corrections, par projet, visibles ou non, passes par cause (classées par Ollama avec --classify, hors quota)
   cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
   raf news new <lot…> [--title t] | list | check | stamp | build [-o dossier]   (aussi « cadence news … »)
 
@@ -300,6 +301,14 @@ function dispatch(argv, io) {
             }
             return 0;
         }
+        case 'todo': {
+            need(1, 'todo <id> [--reason texte]');
+            const plan = loadPlan();
+            plan.putBack(rest[0], today, values.reason ?? '', () => lotWork(plan, root, rest[0]).length);
+            plan.save();
+            io.out(`${rest[0]} → todo`);
+            return 0;
+        }
         case 'note': {
             need(2, 'note <id> "texte"');
             const plan = loadPlan();
@@ -387,6 +396,9 @@ function dispatch(argv, io) {
                 io.out(`screen : ${lot.screen}`);
             if (lot.spec)
                 io.out('spec : true');
+            const gate = gateProgress(plan.lots(), lot);
+            if (lot.gate && gate)
+                io.out(lot.gate.invalid ? `gate : ${gateText(gate)}` : `gate : ${gate.n} lots ${gate.label} faits`);
             if (notes.length) {
                 io.out('notes :');
                 // Les lignes suivantes d'une note multiligne s'alignent sous son texte, pas en colonne 0.
@@ -612,8 +624,12 @@ function now(plan, root, newsDir, today, io) {
         io.out(`  ${describe(l, count(l.id))}`);
     if (ready.length > 5)
         io.out(`  … et ${ready.length - 5} autre(s)`);
-    if (blocked.length)
-        io.out(`  en attente de dépendances : ${blocked.map((l) => l.id).join(', ')}`);
+    const gated = gateWaiting(lots, blocked);
+    const byDeps = blocked.filter((l) => !gated.some((g) => g.lot === l));
+    if (byDeps.length)
+        io.out(`  en attente de dépendances : ${byDeps.map((l) => l.id).join(', ')}`);
+    if (gated.length)
+        io.out(`  en attente de condition de tirage : ${gated.map((g) => `${g.lot.id} (${g.text})`).join(', ')}`);
     const recurring = recurringByDue(lots, today);
     if (recurring.length) {
         io.out('\nRécurrent');
@@ -810,7 +826,7 @@ function waveHolding(root) {
 }
 /**
  * `cadence spec reseal <lot> <test> --reason texte` (L200) : le chemin du lead quand un test d'acceptation scellé du lot EN COURS contredit la fiche.
- * Le test est corrigé dans l'arbre de travail (fiche inchangée) ; la commande refait l'empreinte de ce seul test, journalise la raison dans
+ * Le test est corrigé dans l'arbre de travail (fiche inchangée, ou amendée et commitée par des commits du lot, L217) ; la commande refait l'empreinte de ce seul test, journalise la raison dans
  * acceptation.json, commite test + acceptation (le nouveau commit rouge), et note la raison au lot. Le verrou garde tout le reste.
  */
 const git = (cwd, args) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
@@ -850,7 +866,7 @@ function specReseal(args, reason, porteur, ctx, io) {
     const before = { json: readFileSync(join(repo, json), 'utf8'), test: existsSync(join(repo, test)) ? readFileSync(join(repo, test), 'utf8') : '' };
     let r;
     try {
-        r = resealAcceptation(repo, json, test, reason, ctx.today, livre ? porteur : undefined);
+        r = resealAcceptation(repo, json, test, reason, ctx.today, livre ? porteur : undefined, plan.refs);
     }
     catch (e) {
         throw new RafError(e.message);
@@ -858,7 +874,7 @@ function specReseal(args, reason, porteur, ctx, io) {
     const norm = posix.normalize(test);
     try {
         git(repo, ['add', '--', json, norm]);
-        git(repo, ['commit', '-q', '-m', `test(${cite}): acceptation rescellée${livre ? ` du lot livré ${lotId}` : ''}, ${norm} : ${reason.trim()}`, '--', json, norm]);
+        git(repo, ['commit', '-q', '-m', `test(${cite}): acceptation rescellée${livre ? ` du lot livré ${lotId}` : ''}, ${norm} : ${reason.trim()}${r.ficheAmendee ? ` (fiche amendée en ${r.ficheAmendee})` : ''}`, '--', json, norm]);
     }
     catch (e) {
         // Atomique : un commit refusé (hook pre-commit, ...) ne laisse ni empreinte refaite ni index à moitié prêt ; le test retrouve le texte du lead.
@@ -876,10 +892,10 @@ function specReseal(args, reason, porteur, ctx, io) {
     const sha = git(repo, ['rev-parse', '--short', 'HEAD']).trim();
     // Un plan tenu par un autre outil ne se modifie pas d'ici : la raison est déjà dans acceptation.json et dans le commit, la note reste à la main du lead.
     if (plan.readonly) {
-        io.out(`${lotId} : ${norm} rescellé (${r.avant.slice(0, 7)} → ${r.apres.slice(0, 7)}), commit ${sha} ; raison dans ${json} et dans le commit — note à ajouter au lot ${cite} avec l'outil du projet (plan en lecture seule)`);
+        io.out(`${lotId} : ${norm} rescellé (${r.avant.slice(0, 7)} → ${r.apres.slice(0, 7)}), commit ${sha}${r.ficheAmendee ? `, fiche amendée en ${r.ficheAmendee}` : ''} ; raison dans ${json} et dans le commit — note à ajouter au lot ${cite} avec l'outil du projet (plan en lecture seule)`);
         return 0;
     }
-    plan.note(cite, `test d'acceptation rescellé${livre ? ` (lot livré ${lotId}, ` : ' ('}${norm}, fiche inchangée) : ${reason.trim()}`, ctx.today);
+    plan.note(cite, `test d'acceptation rescellé${livre ? ` (lot livré ${lotId}, ` : ' ('}${norm}, ${r.ficheAmendee ? `fiche amendée en ${r.ficheAmendee}` : 'fiche inchangée'}) : ${reason.trim()}`, ctx.today);
     plan.save();
     // La note du lot rejoint le dépôt dans la foulée (un dépôt sale arrêterait la vague suivante) ; un plan hors du dépôt ou non suivi reste à la main du lead.
     const planRel = relative(repo, plan.path);
@@ -895,7 +911,7 @@ function specReseal(args, reason, porteur, ctx, io) {
             throw new RafError(`spec reseal : le rescellé a eu lieu (commit ${sha}) mais le commit de la note du lot a échoué — la note est écrite dans ${planRel}, à commiter à la main (un plan sale arrêterait la vague suivante) — ${(out.stderr || out.stdout || out.message).trim().split('\n').slice(-5).join(' | ')}`);
         }
     }
-    io.out(`${lotId} : ${norm} rescellé (${r.avant.slice(0, 7)} → ${r.apres.slice(0, 7)}), commit ${sha} ; raison dans ${json} et en note du lot ${cite}${tracked ? '' : ' (plan à commiter)'}`);
+    io.out(`${lotId} : ${norm} rescellé (${r.avant.slice(0, 7)} → ${r.apres.slice(0, 7)}), commit ${sha}${r.ficheAmendee ? `, fiche amendée en ${r.ficheAmendee}` : ''} ; raison dans ${json} et en note du lot ${cite}${tracked ? '' : ' (plan à commiter)'}`);
     return 0;
 }
 /** `cadence spec check|qa <fiche>` (L170) : code 0 valide, 1 écarts, 2 usage ou fichier illisible. `qa` imprime la section expectations.md de l'écran. */
@@ -926,7 +942,7 @@ function spec(rest, io) {
 /** `cadence corrections` (L165) : la mesure de référence des passes de correction d'une vague, lue dans <dossier>/.cadence/runs. */
 async function corrections(rest, values, io) {
     if (rest.length > 1)
-        throw new RafError('usage : cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--json]');
+        throw new RafError('usage : cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--since date] [--json]');
     const parent = resolve(io.cwd, rest[0] ?? '.');
     const runsDir = join(parent, '.cadence', 'runs');
     if (!existsSync(runsDir))
@@ -936,9 +952,11 @@ async function corrections(rest, values, io) {
         throw new RafError(`--sample invalide : ${values.sample}`);
     if (values.until !== undefined && Number.isNaN(Date.parse(values.until)))
         throw new RafError(`--until invalide : ${values.until} (une date ISO, ex. 2026-10-10T18:31Z)`);
+    if (values.since !== undefined && Number.isNaN(Date.parse(values.since)))
+        throw new RafError(`--since invalide : ${values.since} (une date ISO, ex. 2026-10-10T18:31Z)`);
     const model = values.model ?? 'mistral-small3.2:24b';
     const cacheFile = resolve(io.cwd, values.cache ?? join(parent, '.cadence', 'corrections.json'));
-    const data = readRuns(runsDir, values.until);
+    const data = readRuns(runsDir, values.until, values.since);
     const cache = readCache(cacheFile);
     if (values.classify) {
         const classify = ollamaClassifier({ url: io.env.OLLAMA_HOST ?? 'http://localhost:11434', model });

package/dist/corrections.js

@@ -39,24 +39,28 @@ function findingsOf(report) {
 }
 /**
  * Lit les journaux de vague `<runs>/<vague>/<projet>--<lot>.json`. Un lot compte (dénominateur) dès qu'une session
- * d'écriture a abouti (`until` : date ISO, ne lit que les vagues créées jusque-là et, dans chacune, les étapes terminées (`ended`) jusque-là, pour une mesure que ni les vagues suivantes ni une vague encore en cours ne changent ; une vague ou une étape sans date lisible est écartée) ; chaque pas `fix` abouti est une passe, rattachée aux constats de la dernière revue qui la précède.
+ * d'écriture a abouti (`until` : date ISO, ne lit que les vagues créées jusque-là et, dans chacune, les étapes terminées (`ended`) jusque-là, pour une mesure que ni les vagues suivantes ni une vague encore en cours ne changent ; une vague ou une étape sans date lisible est écartée ; `since` : date ISO, ne garde que les lots des vagues créées strictement après, avec toutes leurs passes : une vague rend tous ses briefs depuis la copie de l'outil figée à sa création, c'est la date de la vague, non celle du début d'un lot, qui dit quel brief il a reçu, sauf pour une vague reprise sans instantané ou, avec `--budget projet:lot=+N`, depuis un instantané d'avant L223 : elle tourne alors avec le dist/ et les gabarits courants ; `--until` plus `--since` ne font le total sans borne que si aucune vague créée avant la borne n'est encore reprenable) ; chaque pas `fix` abouti est une passe, rattachée aux constats de la dernière revue qui la précède.
  */
-export function readRuns(runsDir, until) {
+export function readRuns(runsDir, until, since) {
     const lots = [];
     const passes = [];
     if (!existsSync(runsDir))
         return { lots, passes };
     const limit = until === undefined ? Infinity : Date.parse(until);
+    const from = since === undefined ? undefined : Date.parse(since);
     // Sous `until`, une étape compte si elle est terminée avant la date ; sans date de fin lisible, elle est écartée.
     const inTime = (s) => until === undefined || Date.parse(s.ended ?? '') <= limit;
     for (const wave of readdirSync(runsDir).sort()) {
         const waveDir = join(runsDir, wave);
         if (!statSync(waveDir).isDirectory())
             continue;
-        if (until !== undefined) {
+        if (until !== undefined || from !== undefined) {
             // Les vagues nommées à la main (ol-gains-1) n'ont pas d'horodatage dans leur nom : on lit `created` dans wave.json.
             const created = Date.parse(readJson(join(waveDir, 'wave.json'))?.created);
-            if (!(created <= limit))
+            if (until !== undefined && !(created <= limit))
+                continue;
+            // `since` est strict : une vague créée pile à la borne reste dans l'avant de `until` (inclusif), les deux mesures ne se recouvrent jamais ; sans date de création lisible, la vague est dans aucune.
+            if (from !== undefined && !(created > from))
                 continue;
         }
         for (const file of readdirSync(waveDir).sort()) {

package/dist/lead.js

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { basename, join, relative, sep } from 'node:path';
-import { audit, nextUp, planCommits } from './audit.js';
+import { audit, gateWaiting, nextUp, planCommits } from './audit.js';
 import { planLoader, readPlanConfig } from './config.js';
 import { diffDays } from './dates.js';
 import { gitRoot, repoStatus } from './git.js';
@@ -108,7 +108,7 @@ export function tourRow(dir, today, idle = TOUR_IDLE, name = basename(dir)) {
         const plan = planLoader(root)();
         const lots = plan.lots();
         const all = linkCommits(lots, planCommits(plan, root), plan.refs);
-        const { doing, ready } = nextUp(lots);
+        const { doing, ready, blocked } = nextUp(lots);
         row.doing = doing.map((l) => {
             const last = lastActivity(l, all.byLot.get(l.id) ?? []);
             if (!last)
@@ -125,6 +125,9 @@ export function tourRow(dir, today, idle = TOUR_IDLE, name = basename(dir)) {
             todo: counted.filter((l) => l.status === 'todo').length,
             added7: counted.filter((l) => l.created !== undefined && diffDays(l.created, today) >= 0 && diffDays(l.created, today) < ADDED_DAYS).length,
         };
+        const waiting = gateWaiting(lots, blocked).map((g) => g.lot.id);
+        if (waiting.length)
+            row.waiting = waiting;
         row.next = ready[0] ? { id: ready[0].id, title: ready[0].title } : null;
         const s = repoStatus(root);
         if (s.dirty || s.untracked)
@@ -179,5 +182,5 @@ export function tourLine(r) {
         : 'aucune';
     const notes = r.notes.length ? truncate(r.notes.join(' / '), NOTES_MAX) : 'aucune';
     const next = r.next ? `${r.next.id} ${truncate(r.next.title, TITLE_MAX)}` : 'aucun';
-    return [r.project, `en cours ${doing}`, `dérive ${drift}`, `notes : ${notes}`, `prochain ${next}`, `dépôt ${r.repo.length ? r.repo.join(', ') : 'propre'}`].join(' · ');
+    return [r.project, `en cours ${doing}`, `dérive ${drift}`, `notes : ${notes}`, `prochain ${next}`, ...(r.waiting?.length ? [`attend ${r.waiting.join(', ')}`] : []), `dépôt ${r.repo.length ? r.repo.join(', ') : 'propre'}`].join(' · ');
 }

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 });
@@ -122,10 +123,12 @@ 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, porteur) {
+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')
@@ -146,8 +149,20 @@ export function resealAcceptation(repo, path, test, reason, today, porteur) {
         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)`);
@@ -157,9 +172,9 @@ export function resealAcceptation(repo, path, test, reason, today, porteur) {
     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 } : {}) }];
+    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) {

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

@@ -1,3 +1,4 @@
+import { gateProgress, gateText } from '../audit.js';
 import { execFileSync } from 'node:child_process';
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
@@ -18,7 +19,7 @@ import { ficheReviewText } from './fiche.js';
 import { maquetteText } from './maquette.js';
 import { specScreen, specText } from './spec.js';
 import { candidates, parsePriority, parseUntil, readPriority, stopReason } from './continue.js';
-import { Budget, DROPPED, MAX_PASSES, MAX_PASSES_CONVERGING, briefName, countInterrupted, handBackDroppedQuestions, needsPrecheck } from './cycle.js';
+import { Budget, DROPPED, MAX_PASSES, REVIEW_RESERVE, budgetStep, lotSpent, 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,15 +29,16 @@ import { resolveLotRepos } from '../repos.js';
 import { excludeState, lotFinished, lotKey, lotRepoPaths, lotSlug, neighbourDirs, newLot, RunStore } from './state.js';
 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';
+import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveModulesDir, snapshotExists, waveReadsControl, waveReadsLotBudget, withoutLaunchVars, spawnReexec, takeSnapshot, toolDirOf } from './snapshot.js';
 export const DEFAULT_BUDGET = 2_000_000;
 /**
  * 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).
+ * 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. */
@@ -49,9 +51,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,8 +101,27 @@ function lotArg(text) {
         throw new RafError(`modèle inconnu : @${m[3]} (attendu : ${MODELS.join(', ')})`);
     return { project: m[1], lot: m[2], model: m[3] };
 }
+/** `projet:lot=+200k`, `lot=+0.3M` (L223) : le « = » distingue le relèvement d'un lot du budget de la vague. */
+function lotBudgetArg(text) {
+    const bad = () => new RafError(`--budget invalide : ${text} (projet:lot=+500k)`);
+    const m = /^([^=]+)=\+(.+)$/.exec(text);
+    if (!m)
+        throw bad();
+    let target;
+    let raise;
+    try {
+        target = lotArg(m[1]);
+        raise = parseBudget(m[2]);
+    }
+    catch {
+        throw bad();
+    }
+    if (target.model)
+        throw bad();
+    return { project: target.project, lot: target.lot, raise, text: m[2] };
+}
 export function parseOrchestrateArgs(argv) {
-    const a = { lots: [], dryRun: false, waits: false, watch: false, continue: false, answers: [], drop: [], stopAfterCurrent: false };
+    const a = { lots: [], lotBudgets: [], 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];
@@ -127,8 +149,13 @@ export function parseOrchestrateArgs(argv) {
             a.watch = true;
         else if (t === '--interval')
             a.interval = parseMaxSessions(value(t), '--interval');
-        else if (t === '--budget')
-            a.budget = parseBudget(value(t));
+        else if (t === '--budget') {
+            const v = value(t);
+            if (v.includes('='))
+                a.lotBudgets.push(lotBudgetArg(v));
+            else
+                a.budget = parseBudget(v);
+        }
         else if (t === '--max-sessions')
             a.maxSessions = parseMaxSessions(value(t));
         else if (t === '--wave')
@@ -252,6 +279,12 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
             refusals.push(`${key} : dépendance(s) ni terminée(s) ni plus tôt dans la vague : ${open.join(', ')}`);
             continue;
         }
+        // Condition de tirage (L219) : seuls les lots done du plan la lèvent, jamais un lot de la même vague ; un lot déjà doing n'est pas refusé pour elle.
+        const gate = lot.status === 'todo' ? gateProgress(plan.lots(), lot) : undefined;
+        if (gate && !gate.met) {
+            refusals.push(`${key} : condition de tirage non remplie : ${gate.n === 0 ? 'gate invalide (raf check)' : gateText(gate)}`);
+            continue;
+        }
         // Dépôts voisins du lot (L62) : chacun doit exister et être un dépôt git, sinon refus avant d'agir comme pour le dépôt du projet.
         const neighbours = resolveLotRepos(t.repo, lot);
         if (neighbours.problems.length) {
@@ -346,9 +379,9 @@ function dryRun(lots, io, deps, budget, id) {
         if (l.small)
             steps.push({ kind: l.visible ? 'review-small' : 'review', model: l.light ? light : full });
         else {
-            if (l.visible && env.config.ux)
-                steps.push({ kind: 'ux', model: full });
             steps.push({ kind: 'review', model: l.light ? light : full });
+            if (l.visible && env.config.ux)
+                steps.push({ kind: 'ux', model: full }); // L221 : l'UX est jouée une fois, après la revue de code conforme
         }
         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 (${MAX_PASSES_CONVERGING} si la revue converge), en session neuve`);
@@ -453,6 +486,8 @@ 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.lotBudgets.length && args.resume === undefined)
+        throw new RafError("--budget projet:lot=+N ne vaut qu'avec --resume");
     if (args.since !== undefined && !args.waits)
         throw new RafError('--since s\'utilise avec --waits');
     if (args.waits) {
@@ -962,9 +997,15 @@ async function resume(args, argv, io, deps, launch, today) {
         throw new RafError(typeof args.resume === 'string' ? `vague inconnue : ${args.resume}` : 'aucune vague à reprendre dans ce dossier');
     if (deps.snapshot) {
         // La reprise tourne sur l'instantané de la vague, jamais sur le dist/ courant ; une vague d'avant L61 n'en a pas.
-        if (snapshotExists(store.dir))
-            return deps.snapshot.reexec(toolDirOf(store.dir), argv, io.env, io);
-        io.err(`orchestrate : vague ${store.id} sans instantané (antérieure à L61) : reprise avec le dist/ et les gabarits courants`);
+        if (snapshotExists(store.dir)) {
+            // Une vague d'avant L223 refuserait « projet:lot=+N » comme budget invalide : seul le lot visé justifie de la rejouer avec le dist/ courant.
+            if (!args.lotBudgets.length || waveReadsLotBudget(store.dir))
+                return deps.snapshot.reexec(toolDirOf(store.dir), argv, io.env, io);
+            io.err(`orchestrate : vague ${store.id} : son instantané ne connaît pas --budget projet:lot=+N (antérieur à L223) : reprise avec le dist/ et les gabarits courants`);
+        }
+        else {
+            io.err(`orchestrate : vague ${store.id} sans instantané (antérieure à L61) : reprise avec le dist/ et les gabarits courants`);
+        }
     }
     const wave = store.readWave();
     const refusals = [];
@@ -974,7 +1015,8 @@ async function resume(args, argv, io, deps, launch, today) {
     const alive = liveWaves(cadenceHome()).find((w) => w.wave === wave.id && w.cwd === launch && w.pid !== process.pid);
     if (alive)
         refusals.push(`la vague ${alive.wave} tourne encore (pid ${alive.pid})`);
-    if (wave.status === 'done')
+    // Une vague terminée ne se reprend que pour rejouer un lot visé par --budget projet:lot=+N (L223) ; ce lot est vérifié plus bas.
+    if (wave.status === 'done' && !args.lotBudgets.length)
         refusals.push(`la vague ${wave.id} est terminée`);
     const lots = store.lots();
     for (const a of args.answers) {
@@ -1001,11 +1043,37 @@ async function resume(args, argv, io, deps, launch, today) {
         else
             drops.push(lotKey(matches[0].project, matches[0].lot));
     }
+    // --resume --budget projet:lot=+N (L223) : un lot rendu sur budget est remis en jeu avec son budget relevé. Il subit ensuite les gardes d'un lot vivant.
+    const raised = new Map();
+    const answered = args.answers.map((a) => lots.filter((x) => x.lot === a.lot && (a.project ? x.project === a.project : true))).filter((m) => m.length === 1).map((m) => m[0]);
+    const dropped = args.drop.map((d) => lots.filter((x) => x.lot === d.lot && (d.project ? x.project === d.project : true))).filter((m) => m.length === 1).map((m) => m[0]);
+    for (const b of args.lotBudgets) {
+        const matches = lots.filter((x) => x.lot === b.lot && (b.project ? x.project === b.project : true));
+        const where = `${b.project ? `${b.project}:` : ''}${b.lot}`;
+        if (matches.length !== 1) {
+            refusals.push(matches.length ? `--budget ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--budget ${where} : lot inconnu dans la vague ${wave.id}`);
+            continue;
+        }
+        const l = matches[0];
+        const key = lotKey(l.project, l.lot);
+        if (raised.has(l))
+            refusals.push(`--budget ${key} : lot visé deux fois`);
+        else if (dropped.includes(l))
+            refusals.push(`--budget ${key} : lot aussi retiré par --drop`);
+        else if (answered.includes(l))
+            refusals.push(`--budget ${key} : lot aussi visé par --answer`);
+        else if (!budgetStep(l))
+            refusals.push(`--budget ${key} : le lot n'est pas rendu sur budget avec une étape d'écriture à rejouer (${l.status}${l.status === 'handed-back' ? `, étape ${l.next ?? 'aucune'} : ${l.outcome ?? 'sans cause'}` : ''})`);
+        else if (budgetStep(l) === 'fix' && b.raise <= REVIEW_RESERVE)
+            refusals.push(`--budget ${key}=+${b.text} : un fix ne part qu'au-dessus de ${REVIEW_RESERVE} tokens de réserve`);
+        else
+            raised.set(l, { from: l.budget ?? lotSpent(l), to: lotSpent(l) + b.raise, step: budgetStep(l) });
+    }
     // Un lot retiré ne jouera rien : il ne subit ni le verrou du dépôt, ni le .nvmrc, ni l'arbre sale — un refus pour LUI ne doit pas faire échouer la reprise des autres.
     const live = [];
     const removed = [];
     for (const l of lots) {
-        if (lotFinished(l))
+        if (lotFinished(l) && !raised.has(l))
             continue;
         for (const s of l.steps) {
             if (s.status !== 'running')
@@ -1063,6 +1131,17 @@ async function resume(args, argv, io, deps, launch, today) {
     wave.cacheRead += recovered.cacheRead;
     if (recovered.consumed || recovered.cacheRead)
         store.writeWave(wave);
+    for (const [l, r] of raised) {
+        const k = lotKey(l.project, l.lot);
+        const text = `budget relevé de ${r.from} à ${r.to} (--resume --budget)`;
+        l.budget = r.to;
+        l.status = 'suspended';
+        l.next = r.step;
+        l.outcome = null;
+        l.warnings.push(text);
+        store.journal(`${k} → suspended — ${text}`);
+        io.out(`${k} → suspended — ${text}`);
+    }
     for (const l of live) {
         if (l.status === 'implementing' || l.status === 'reviewing' || l.status === 'fixing')
             l.status = 'suspended';