@sylad/cadence 1.42.1 → 1.43.0

package/dist/orchestrate/cycle.js

@@ -40,7 +40,7 @@ import { answeredText, checkSpec, costlyHypotheses, ficheHasBack, ficheReady, fi
 import { handBackWithoutFinding } from './no-finding.js';
 import { decisionsText, humanDecisions } from './decisions.js';
 import { LOCAL_PRECHECK_UNREADABLE, PRECHECK_UNREADABLE, expressSummary, lotKey, lotRepoPaths, neighbourDirs } from './state.js';
-import { advance, baseMoved, INTEGRATE_WAIT_MS, MAX_REPLAYS, mergeBase, patchId, rebaseOnto, repoBranch, takeRepoWrite } from './integrate.js';
+import { advance, baseMoved, INTEGRATE_WAIT_MS, MAX_REPLAYS, mergeBase, patchId, rebaseNotes, rebaseOnto, repoBranch, takeRepoWrite } from './integrate.js';
 import { mutexFor } from './mutex.js';
 import { readTier, stillThird, takeTiers, tierMoved, tierRepos, wipBranch } from './tiers.js';
 import { branchExists, git, gitFailure, integrated, linkIgnored, lotBranch, planFileSet, planSeenFrom, prepareTree, removeTree, trackedDirty } from './worktree.js';
@@ -2828,12 +2828,8 @@ async function integrateLot(c) {
                 if (rebased.kind === 'conflict') {
                     return refuse(`intégration impossible : conflit en rebasant ${t.branch} sur ${t.base}${rebased.files.length ? ` (fichiers : ${rebased.files.join(', ')})` : ` (${rebased.detail})`} ; ${kept}`);
                 }
-                if (rebased.kind === 'rebased' && rebased.changelog > 0)
-                    c.wave.log(`${key} CHANGELOG.md : conflit d'ajout pur résolu par union sous [Unreleased] (${rebased.changelog} commit(s))`);
-                if (rebased.kind === 'rebased' && rebased.moved > 0)
-                    c.wave.log(`${key} CHANGELOG.md : ${rebased.moved} entrée(s) du lot replacée(s) sous [Unreleased], une publication a eu lieu pendant la branche`);
-                if (rebased.kind === 'rebased' && rebased.settled)
-                    c.wave.log(`${key} CHANGELOG.md : une entrée finale par lot, les versions intermédiaires du lot écartées`);
+                if (rebased.kind === 'rebased')
+                    rebaseNotes(rebased, key).forEach((note) => c.wave.log(note));
                 const tip = git(t.dir, 'rev-parse', 'HEAD');
                 if (tip !== reviewed) {
                     // Le rebase a changé les commits : tests et build rejoués au sommet rebasé, avant que la branche du dépôt ne bouge (R7).

package/dist/orchestrate/draw.js

@@ -0,0 +1,62 @@
+import { gitRoot } from '../git.js';
+import { candidates, readPriority } from './continue.js';
+import { lotKey, lotRepoPaths } from './state.js';
+import { preflight } from './preflight.js';
+export const priorityOf = (args, launch) => args.priority ?? readPriority(launch);
+/**
+ * Tire jusqu'à `n` lots prêts du plan (L147), dans l'ordre de priorité, et les passe au contrôle préalable comme un lot donné :
+ * un lot refusé est sauté, sa cause rendue dans `skipped`. `exclude` reçoit chaque lot tiré ou refusé pour lui-même, pas ceux d'un
+ * dépôt refusé ni un lot qui ne tient pas dans le reste du budget (il tiendra peut-être au tour suivant).
+ * Un tour tire au plus UN lot par dépôt (le pool joue à la suite les lots d'un même dépôt, `--max-sessions` ne servirait à rien) ;
+ * les lots écartés pour cela complètent le tour, dans l'ordre, quand aucun autre dépôt n'a de lot prêt.
+ */
+export async function draw(args, io, deps, launch, exclude, remaining, n) {
+    const lots = [];
+    const skipped = [];
+    const badRepos = new Set();
+    const used = new Set();
+    const deferred = [];
+    /** `spread` : premier passage, un dépôt déjà pris ce tour renvoie le lot au second ; sinon (second passage) le lot complète le tour. */
+    const attempt = async (c, repo, spread, checked) => {
+        const key = lotKey(c.project, c.lot.id);
+        if (badRepos.has(repo))
+            return;
+        if (spread && used.has(repo))
+            return void deferred.push({ c, repo });
+        const pre = checked ?? (await preflight(args, [{ project: c.project, projectDir: c.dir, repo, lot: c.lot.id, model: 'sonnet' }], io, deps, launch));
+        if (pre.refusals.length) {
+            // Un refus propre au lot l'écarte pour la vague ; celui d'un dépôt (arbre sale, orchestration en cours, pre-push) est passager :
+            // le dépôt est sauté pour ce tirage seulement, une ligne, et ses lots restent tirables au suivant.
+            const own = pre.refusals.filter((r) => r.startsWith(`${key} : `));
+            if (own.length)
+                exclude.add(key);
+            if (own.length < pre.refusals.length)
+                badRepos.add(repo);
+            skipped.push(...pre.refusals.filter((r) => !skipped.includes(r)));
+            return;
+        }
+        const lot = pre.lots[0];
+        if (lot.budget > remaining)
+            return; // pas exclu : le budget du tour suivant le permettra peut-être
+        if (spread && lotRepoPaths(lot).some((r) => used.has(r)))
+            return void deferred.push({ c, repo, pre }); // un dépôt voisin déjà pris ce tour
+        exclude.add(key);
+        remaining -= lot.budget;
+        lots.push(lot);
+        for (const r of lotRepoPaths(lot))
+            used.add(r);
+    };
+    for (const c of candidates(launch, { priority: priorityOf(args, launch), exclude, remaining })) {
+        if (lots.length >= n)
+            break;
+        const repo = gitRoot(c.dir);
+        if (repo)
+            await attempt(c, repo, true);
+    }
+    for (const d of deferred) {
+        if (lots.length >= n)
+            break;
+        await attempt(d.c, d.repo, false, d.pre);
+    }
+    return { lots, skipped };
+}

package/dist/orchestrate/dry-run.js

@@ -0,0 +1,223 @@
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import { readPlanConfig } from '../config.js';
+import { PLAN_ACTIONS, commitMsgHook, leadAnswerMessage, commitMsgRefusal, planCommitMessage } from '../plan-commit.js';
+import { decisionsText, humanDecisions } from './decisions.js';
+import { headline, newsText, objective, renderBrief } from './briefs.js';
+import { acceptationFile, acceptText, redAcceptations } from './accept.js';
+import { noTestGate, noTestText } from './no-test.js';
+import { ficheReviewText } from './fiche.js';
+import { maquetteText } from './maquette.js';
+import { budgetStage, costlyHypotheses, lightLot, specText } from './spec.js';
+import { fichesDuDossier } from '../spec.js';
+import { drawSettingsReport } from './continue.js';
+import { precheckNothingToFind, MAX_PASSES, MAX_PASSES_CONVERGING, briefName, needsPrecheck } from './cycle.js';
+import { buildArgs, buildLocalArgs, MODEL_ALIASES, mcpServersFor, enabledPlugins, settingsFiles } from './launch.js';
+import { repoBranch } from './integrate.js';
+import { effortKey, schemaFor, stepAgent } from './schemas.js';
+import { lotKey, lotSlug, neighbourDirs, RunStore } from './state.js';
+import { matchesNvmrc, notLoggedIn, pathNodeVersion, projectEnv } from './preflight.js';
+import { draw, priorityOf } from './draw.js';
+import { agentsOf } from './preflight.js';
+import { lotBudgetBasis } from './lot-budget.js';
+/**
+ * Ce avec quoi le dry-run mesure les messages de la fiche d'un lot à étape spec (L343) : la fiche du lot quand elle est déjà écrite (son sujet pour les hypothèses
+ * notées, ses hypothèses coûteuses pour la réponse du lead, qui ne source que les règles posées en question — `costlyHypotheses` — et n'est pas commitée sans elles),
+ * sinon le sujet le plus long du dossier des fiches et autant de règles coûteuses que la fiche du dossier qui en porte le plus (1 au moins). Un sujet de 7 caractères
+ * (« <sujet> ») faisait accepter un message que `header-max-length` refuse avec un sujet réel ; toutes les hypothèses d'une fiche (13) faisaient refuser une réponse qui n'en cite que les coûteuses.
+ */
+function ficheMeasure(repo, dir, lot) {
+    const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+    const costly = (doc) => costlyHypotheses(doc).map((x) => x.id);
+    const fiches = fichesDuDossier(repo, dir);
+    const mine = fiches.find(({ doc }) => (isObj(doc.sujet) && doc.sujet.lot === lot) || (isObj(doc.ecran) && doc.ecran.lot === lot));
+    if (mine) {
+        const sujet = isObj(mine.doc.sujet) && typeof mine.doc.sujet.id === 'string' ? mine.doc.sujet.id : mine.name;
+        const regles = costly(mine.doc);
+        const about = regles.length ? `réponse du lead mesurée avec ${regles.length > 1 ? 'les règles coûteuses' : 'la règle coûteuse'} ${regles.join(', ')}` : 'aucune hypothèse coûteuse : pas de réponse du lead à commiter';
+        return { sujet, regles, line: `  fiche du lot : ${dir}/${mine.name}/fiche.yaml (${about})` };
+    }
+    if (!fiches.length)
+        return { sujet: '<sujet>', regles: ['R1'], line: `  aucune fiche dans ${dir} : les messages de la fiche sont mesurés avec « <sujet> » (7 caractères) et 1 règle ; un sujet réel plus long peut dépasser une limite du hook` };
+    const sujet = fiches.map((f) => f.name).reduce((a, b) => (b.length > a.length ? b : a));
+    const n = Math.max(1, ...fiches.map((f) => costly(f.doc).length));
+    return { sujet, regles: Array.from({ length: n }, (_, i) => `R${i + 1}`), line: `  fiche du lot pas encore écrite : mesure avec le sujet le plus long de ${dir} (${sujet}) et ${n} règle(s) coûteuse(s) pour la réponse du lead` };
+}
+/**
+ * Les messages de commit de plan que la vague écrirait pour ce lot, passés au hook commit-msg réel du dépôt : un refus se lit ici, avant une vague payante (L343).
+ * Les messages de la fiche (hypothèses, mineurs de sa revue, réponse du lead) ne sont joués que pour un lot à étape spec, avec un sujet de longueur réelle (`ficheMeasure`) ;
+ * les hypothèses ne sont notées que pour un lot `spec: true` sans écran (`settleHypotheses`), la réponse du lead n'est commitée que pour une hypothèse coûteuse (`sourceAnsweredRules`).
+ */
+function planMessageLines(repo, l, wave, dir) {
+    const template = readPlanConfig(join(repo, 'cadence.yaml'), repo)?.commit;
+    const specStage = !!(l.screen || l.specLot);
+    const measure = specStage ? ficheMeasure(repo, dir, l.lot) : null;
+    const actions = [PLAN_ACTIONS.started, PLAN_ACTIONS.reviewRecorded, PLAN_ACTIONS.reviewNoted];
+    if (measure) {
+        if (l.specLot && !l.screen)
+            actions.push(PLAN_ACTIONS.hypotheses(measure.sujet));
+        actions.push(PLAN_ACTIONS.minors('la fiche'));
+    }
+    const planMessages = actions.map((action) => planCommitMessage(template, { lot: l.lot, action, wave }));
+    const messages = [...new Set(measure?.regles.length ? planMessages.concat(leadAnswerMessage(template, l.lot, measure.regles, wave)) : planMessages)];
+    const hook = commitMsgHook(repo);
+    if (!hook)
+        return template ? [`  messages de plan : « ${messages[0]} » (gabarit plan.commit ; aucun hook commit-msg dans ce dépôt)`] : [];
+    const refused = messages.map((m) => ({ m, why: commitMsgRefusal(repo, m) })).filter((r) => r.why !== null);
+    const about = measure ? [measure.line] : [];
+    if (!refused.length)
+        return [`  messages de plan : ${messages.length} message(s) acceptés par le hook commit-msg du dépôt (${hook})${template ? ' — gabarit plan.commit' : ''}`, ...about];
+    return [
+        ...refused.map((r) => `  ✗ message de plan refusé par le hook commit-msg : « ${r.m} » — ${r.why}`),
+        ...about,
+        `  ✗ le lot échouerait au premier commit de plan refusé, avant ou pendant ses sessions : régler plan.commit dans cadence.yaml (gabarit avec {lot}, {action}, {vague})`,
+    ];
+}
+/** `wave` : la vague simulée — son identifiant, son budget et si elle a plus d'un créneau (L527 : tout lot d'un dépôt en worktrees y joue alors dans le sien). */
+export function dryRun(lots, io, deps, { budget, id, multiSlot }) {
+    const tmp = mkdtempSync(join(tmpdir(), 'cadence-orchestrate-'));
+    const agents = agentsOf(deps);
+    io.out(`vague ${id} — simulation, rien n'est lancé (budget ${budget} tokens comptés)`);
+    const login = notLoggedIn(deps);
+    if (login)
+        io.out(`⚠ ${login} — sans cela le vrai lancement est refusé`);
+    const repos = [...new Set(lots.map((l) => l.repo))];
+    const noTestSaid = new Set();
+    const redSaid = new Set();
+    for (const l of lots) {
+        const env = projectEnv(l.repo);
+        const lot = env.loadPlan().lot(l.lot);
+        const slot = repos.indexOf(l.repo);
+        io.out(`${lotKey(l.project, l.lot)} — ${l.title}`);
+        if (l.goal)
+            io.out(`  objectif donné : ${l.goal} (à la place du titre dans les briefs)`);
+        io.out(`  budget du lot : ${l.budget} tokens comptés (base : ${lotBudgetBasis(lot.estimate, budgetStage(lot, l.screen, env.config.maquette, l.repo, env.config.spec.dir), l.escalationReserve ? env.config.escalation?.model : undefined)})`);
+        const mine = lots.filter((o) => o.repo === l.repo);
+        const together = env.config.worktrees && (mine.length > 1 || multiSlot) && !mine.some((o) => o.repos?.length) && !!repoBranch(l.repo);
+        io.out(together ? `  file ${basename(l.repo)} · en parallèle des autres lots du dépôt, dans son worktree (cadence/${id}/${lotSlug(l.project, l.lot)}, créé à la prise du créneau)` : `  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})`);
+        if (l.node) {
+            const sk = l.node.skipped;
+            const skipped = sk?.length ? ` ; ${sk.join(', ')} ${sk.length > 1 ? 'écartées' : 'écartée'} : pas de node exécutable` : '';
+            io.out(`  node : ${l.node.version} (.nvmrc ${l.node.wanted}${skipped})`);
+            const gate = env.config.test || env.config.build;
+            const onPath = gate ? (deps.pathNode ?? (() => pathNodeVersion(io.env)))() : null;
+            if (onPath && !matchesNvmrc(onPath, l.node.wanted))
+                io.out(`  ⚠ .nvmrc ${l.node.wanted} ≠ node du PATH ${onPath} : la porte et les autres commandes du programme tournent sous ${l.node.version} (lien node-bin en tête du PATH), pas sous ${onPath}`);
+        }
+        const steps = [{ kind: 'implement', model: l.model }];
+        const specStage = !!(l.screen || l.specLot);
+        if (specStage && env.config.accept && !lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir))
+            steps.unshift({ kind: 'accept', model: 'sonnet' });
+        if (l.screen && env.config.maquette)
+            steps.unshift({ kind: 'maquette', model: env.config.review.full });
+        if (l.specLot && env.config.fiche)
+            steps.unshift({ kind: 'fiche', model: 'sonnet' });
+        if (specStage)
+            steps.unshift({ kind: 'spec', model: 'sonnet' });
+        if (!l.express && needsPrecheck(env.config, env.loadPlan(), l.repo, l.lot, l.repos, l.goal)) {
+            const nothingToFind = precheckNothingToFind(env.loadPlan(), l.repo, l.lot, l.repos, l.goal);
+            if (nothingToFind)
+                io.out(`  contrôle préalable sauté : ${nothingToFind}`);
+            else
+                steps.unshift({ kind: 'precheck', model: env.config.precheckLocal ? 'local' : 'sonnet' });
+        }
+        steps.push(...(env.config.probe && !l.express ? [{ kind: 'probe', model: 'sonnet' }] : [])); // L497 : entre l'écriture et la revue
+        const { light, full } = env.config.review;
+        if (l.express) {
+            // L519 : une seule session, le lead lit le diff
+        }
+        else if (l.small)
+            steps.push({ kind: l.visible ? 'review-small' : 'review', model: l.light ? light : full });
+        else {
+            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.express ? ' — voie express (pas de précheck, de sonde ni de revue séparée : le lead lit le diff)' : ''}${l.light && !l.express ? ` — 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)' : ''}`);
+        for (const m of new Set(steps.map((s) => s.model))) {
+            if (m !== 'local' && !MODEL_ALIASES.includes(m))
+                io.out(`  ⚠ modèle « ${m} » hors des alias ${MODEL_ALIASES.join(', ')} : passé tel quel à claude --model (un nom que le compte ne connaît pas fait échouer la session)`);
+        }
+        for (const line of planMessageLines(l.repo, l, id, env.config.spec.dir))
+            io.out(line);
+        const noTest = noTestSaid.has(l.repo) ? null : noTestGate(l.repo);
+        noTestSaid.add(l.repo);
+        if (noTest)
+            io.out(`  ${basename(l.repo)} · ${noTestText(noTest)}`);
+        if (!redSaid.has(l.repo)) {
+            redSaid.add(l.repo);
+            // L366 : l'acceptation à vert: false d'un lot clos à la main verrouille ses tests pour tous les lots du dépôt, sans que ce lot y ait touché.
+            const closed = new Set(env.loadPlan().lots().filter((x) => x.status === 'done').map((x) => x.id));
+            for (const red of redAcceptations(l.repo, env.config.spec.dir)) {
+                if (closed.has(red.lot))
+                    io.out(`  ⚠ ${basename(l.repo)} · acceptation rouge d'un lot clos : ${red.lot} (${red.path}, vert: false) — le verrou des tests d'acceptation peut bloquer les lots de la vague ; cadence spec green ${red.lot}`);
+            }
+        }
+        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: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', ux: '', choix: '', checks: '', news: l.visible ? newsText(l.lot) : '', captures: '', diff: 'git diff <sha de départ>..HEAD' };
+        vars.decisions = decisionsText(humanDecisions(lot, lot.parent ? env.loadPlan().lots().find((x) => x.id === lot.parent) : undefined));
+        if (specStage)
+            vars.spec = specText({ dir: env.config.spec.dir, render: env.config.spec.render, screen: l.screen, light: lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir), back: !!l.specLot });
+        if (l.screen && env.config.maquette)
+            vars.maquette = maquetteText({ fiche: `${env.config.spec.dir}/<écran>/fiche.yaml`, passes: 0, max: env.config.maquetteReviews, light: lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir) });
+        if (l.specLot && env.config.fiche)
+            vars.fiche = ficheReviewText({ fiche: `${env.config.spec.dir}/<sujet>/fiche.yaml`, passes: 0 });
+        if (specStage && env.config.accept && !lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir)) {
+            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`);
+            writeFileSync(file, 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
+            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[effortKey(s.kind)], schema: schemaFor(s.kind), agent: stepAgent(s.kind), 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, disablePlugins: enabledPlugins(settingsFiles(deps.claudeHome, l.repo)) }, 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, !!l.screen));
+            io.out(`    mcp : ${servers.length ? `${servers.join(', ')} (captures dans le dossier de la vague : <vague>/${lotSlug(l.project, l.lot)}/playwright)` : 'aucun'}`);
+        }
+    }
+}
+/** Le plus de lots que `--dry-run --continue` liste après le premier tirage. */
+const DRY_RUN_LOTS = 10;
+/**
+ * `--dry-run --continue` : ce que le remplissage des créneaux libres tirerait ensuite (L527), avec la même fonction `draw` que la vague, un lot à la fois
+ * (`n = 1` : le premier lot prêt dans l'ordre de priorité, contrôle préalable, budget), comme la vague remplit chaque créneau libre ; les lots sautés disent pourquoi.
+ * Le budget est décompté sur l'estimation des lots tirés (la consommation réelle n'est pas connue) et la simulation ne sait pas quel dépôt sera occupé à chaque
+ * regard : elle liste les lots dans l'ordre où le remplissage les prendrait si chaque dépôt était libre. `firstSkipped` : causes écartées au premier tirage, quand il a fourni les lots donnés.
+ */
+export async function continueDryRun(args, io, deps, launch, given, budget, firstSkipped) {
+    io.out(`--continue : priorité ${priorityOf(args, launch).join(' > ') || '(aucune déclarée : ordre alphabétique)'}${args.until ? ` · jusqu'à ${args.until}` : ''}`);
+    const said = new Set();
+    const skip = (causes) => {
+        for (const s of causes) {
+            if (said.has(s))
+                continue;
+            said.add(s);
+            io.out(`  lot sauté — ${s}`);
+        }
+    };
+    skip(firstSkipped);
+    const exclude = new Set(given.map((l) => lotKey(l.project, l.lot)));
+    for (const line of drawSettingsReport(launch, exclude))
+        io.out(`  ${line}`);
+    let remaining = budget - given.reduce((sum, l) => sum + (l.budget ?? 0), 0);
+    const next = [];
+    while (next.length < DRY_RUN_LOTS && remaining > 0) {
+        const drawn = await draw(args, io, deps, launch, exclude, remaining, 1);
+        skip(drawn.skipped);
+        const lot = drawn.lots[0];
+        if (!lot)
+            break;
+        next.push(lotKey(lot.project, lot.lot));
+        remaining -= lot.budget ?? 0;
+    }
+    io.out(next.length ? `  tirés ensuite, un par un au fil des créneaux libres, dans l'ordre de priorité (budget décompté sur les estimations) : ${next.join(', ')}${next.length === DRY_RUN_LOTS ? ' · …' : ''}` : '  aucun autre lot prêt à tirer');
+}