@sylad/cadence 1.4.0 → 1.6.0

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');
@@ -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/config.js

@@ -223,10 +223,10 @@ const EFFORTS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
 export const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'fiche', 'accept', 'implement', 'fix', 'review', 'ux'];
 const MODELS = ['haiku', 'sonnet', 'opus'];
 const REVIEW_KEYS = ['threshold', 'light', 'full'];
-const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'accept', 'maquette', 'fiche', 'ux', 'precheck', 'prodAccess', 'spec', 'review', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'prodAccess', 'spec', 'review', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
 /** Clé `orchestrate:` de cadence.yaml. Absente : les défauts (auto, 45 min d'implémentation, 25 min de revue). */
 export function readOrchestrateConfig(file) {
-    const config = { precheck: true, maquette: true, fiche: true, precheckLocal: false, prodAccess: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', fiche: 'medium', accept: 'medium', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
+    const config = { precheck: true, maquette: true, maquetteReviews: 3, fiche: true, precheckLocal: false, prodAccess: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', fiche: 'medium', accept: 'medium', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
     if (!existsSync(file))
         return config;
     let raw;
@@ -272,6 +272,11 @@ export function readOrchestrateConfig(file) {
             throw bad('maquette : true ou false attendu');
         config.maquette = o.maquette;
     }
+    if (o.maquetteReviews != null) {
+        if (typeof o.maquetteReviews !== 'number' || !Number.isInteger(o.maquetteReviews) || o.maquetteReviews < 1)
+            throw bad('maquetteReviews : entier supérieur ou égal à 1 attendu');
+        config.maquetteReviews = o.maquetteReviews;
+    }
     if (o.fiche != null) {
         if (typeof o.fiche !== 'boolean')
             throw bad('fiche : true ou false attendu');

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

@@ -251,16 +251,22 @@ export function lotStartHead(repo, work) {
         return undefined;
     return git(repo, 'rev-parse', `${oldest.sha}^`).trim();
 }
-/** La fiche a changé depuis `since` (commits et arbre de travail), ou dans l'un des commits `cites` (ceux qui citent le lot). Illisible pour git : non (le verrou reste entier). */
-function ficheChanged(repo, since, fiche, cites = []) {
+/**
+ * La fiche a été amendée par l'un des commits `cites` (ceux qui citent le lot en cours) postérieur au commit rouge `red` (descendant strict) : seule voie d'ouverture de
+ * l'exception L183 (L231). Un diff d'arbre de travail, un commit d'un autre lot ou un commit antérieur ou égal au rouge n'ouvre rien. Illisible pour git : non (le verrou reste entier).
+ */
+function ficheAmended(repo, red, fiche, cites = []) {
+    return cites.some((sha) => sha !== red && gitOk(repo, 'merge-base', '--is-ancestor', red, sha) && gitOk(repo, 'diff-tree', '--root', '--no-commit-id', '--name-only', '-r', sha, '--', fiche) && git(repo, 'diff-tree', '--root', '--no-commit-id', '--name-only', '-r', sha, '--', fiche).trim() !== '');
+}
+/** Le premier commit fautif (L231) : le plus ancien commit après `since` qui a touché le chemin `file` (modification, suppression ou renommage, sans suivre les renommages), « <sha7> <sujet> » ; vide si aucun commit ne l'a touché (écart de l'arbre de travail). */
+function firstCommitTouching(repo, since, file) {
     try {
-        if (git(repo, 'diff', '--name-only', since, '--', fiche).trim() !== '')
-            return true;
+        const first = git(repo, 'log', '--reverse', '--format=%H %s', `${since}..HEAD`, '--', file).split('\n').find(Boolean);
+        return first ? `${first.slice(0, 7)}${first.slice(40)}` : '';
     }
     catch {
-        return false;
+        return '';
     }
-    return cites.some((sha) => gitOk(repo, 'diff-tree', '--root', '--no-commit-id', '--name-only', '-r', sha, '--', fiche) && git(repo, 'diff-tree', '--root', '--no-commit-id', '--name-only', '-r', sha, '--', fiche).trim() !== '');
 }
 /**
  * Le verrou (spec etape-spec § 5), valable pour toute session du dépôt : les tests d'acceptation de TOUS les lots sont inchangés depuis leur
@@ -269,9 +275,10 @@ function ficheChanged(repo, since, fiche, cites = []) {
  * Un fichier neuf est un écart, sauf `skip` : le fichier du lot que l'étape accept est en train d'écrire, pas encore scellé (les autres lots restent
  * verrouillés, y compris contre un fichier d'un autre lot créé au passage). `rouge` : le commit rouge rangé dans l'état du cycle pour un fichier ; si
  * le dernier commit qui l'a réécrit n'est plus celui-là, une session précédente (interrompue, donc jamais comparée) l'a réécrit.
- * Exception (L183) : une acceptation à `vert: true` (lot livré) laisse modifier ses tests listés si la fiche de l'écran a changé depuis `lotBase` (la
- * tête d'avant le premier travail du lot, par défaut `headBefore`), arbre de travail compris, ou dans un commit de `lotCommits` (ceux qui citent le lot,
- * posés avant la vague) : la fiche fait évoluer les règles. L'acceptation du lot en cours garde le verrou entier de l'exception L183.
+ * Exception (L183, resserrée par L231) : une acceptation à `vert: true` (lot livré) laisse modifier ses tests listés si sa fiche a été amendée par un commit de `lotCommits`
+ * (ceux qui citent le lot en cours) postérieur à son commit rouge (descendant strict) : le lot en cours fait évoluer les règles. Une fois ouverte, l'exception couvre toute
+ * l'acceptation (même commit que la fiche, commit ultérieur, session suivante). Un amendement par un autre lot, ou non commité (arbre de travail), n'ouvre rien. L'acceptation
+ * du lot en cours garde le verrou entier. Le message d'un test modifié nomme le premier commit fautif (`firstCommitTouching`), absent quand aucun commit ne l'a touché.
  * Une fois livrée, une acceptation n'est plus comparée à son commit rouge (une évolution admise l'a dépassé et rien ne le rescelle) mais à `lotBase` :
  * un test changé avant ce point l'a été par un lot qui avait la fiche pour lui, et ses empreintes scellées ne valent plus.
  * Une seule exemption en plus (L184) : un fichier listé dont le contenu est identique à celui qu'il avait à `lotStart` (la tête d'avant le premier commit de
@@ -321,7 +328,7 @@ export function lockViolations(repo, dir, headBefore, opts = {}) {
         if (cur.vert === true && typeof base.fiche === 'string' && base.lot !== opts.lot) {
             // L'acceptation du lot en cours (vert posé dès l'implement) garde le verrou entier : l'exception ne vaut que pour un lot suivant.
             const ref = opts.lotBase ?? headBefore;
-            if (ficheChanged(repo, ref, base.fiche, opts.lotCommits))
+            if (ficheAmended(repo, red, base.fiche, opts.lotCommits))
                 continue;
             // La référence ne quitte le commit rouge que si la fiche a évolué entre le rouge et `ref` : sinon tout test changé depuis le rouge reste un écart.
             if (gitOk(repo, 'diff', '--name-only', red, ref, '--', base.fiche) && git(repo, 'diff', '--name-only', red, ref, '--', base.fiche).trim() !== '') {
@@ -356,8 +363,10 @@ export function lockViolations(repo, dir, headBefore, opts = {}) {
             if (have !== want)
                 out.push(`${f} : empreinte différente de celle du scellé de ${p} (test d'acceptation de ${lot})`);
         }
-        for (const f of changed)
-            out.push(`${f} : test d'acceptation de ${lot} : empreinte modifiée depuis ${depuis === red ? 'le commit rouge' : 'la tête d\'avant le lot'} ${depuis.slice(0, 7)} (verrou ${p})`);
+        for (const f of changed) {
+            const culprit = firstCommitTouching(repo, depuis, f);
+            out.push(`${f} : test d'acceptation de ${lot} : empreinte modifiée depuis ${depuis === red ? 'le commit rouge' : 'la tête d\'avant le lot'} ${depuis.slice(0, 7)} (verrou ${p})${culprit ? ` ; premier commit fautif : ${culprit}` : ''}`);
+        }
     }
     return out;
 }

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,7 +29,7 @@ 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
@@ -100,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];
@@ -129,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')
@@ -254,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) {
@@ -348,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`);
@@ -361,7 +392,7 @@ function dryRun(lots, io, deps, budget, id) {
         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 });
+            vars.maquette = maquetteText({ fiche: `${env.config.spec.dir}/<écran>/fiche.yaml`, passes: 0, max: env.config.maquetteReviews });
         if (l.specLot && env.config.fiche)
             vars.fiche = ficheReviewText({ fiche: `${env.config.spec.dir}/<sujet>/fiche.yaml`, passes: 0 });
         if (specStage && env.config.accept) {
@@ -455,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) {
@@ -964,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 = [];
@@ -976,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) {
@@ -1003,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')
@@ -1065,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';