@sylad/cadence 1.38.1 → 1.40.0

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "cadence",
       "description": "Session start and close rituals driven by a versioned plan (raf), and deliveries proven by their effect. Needs the cadence CLI (npm i -g @sylad/cadence).",
-      "version": "1.38.1",
+      "version": "1.40.0",
       "source": "./",
       "author": {
         "name": "Sylvain Ladoire"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cadence",
   "description": "A repo-native working method: session start and close rituals driven by a versioned plan (raf), deliveries proven by their effect, and three reviewer agents (UX, code, QA).",
-  "version": "1.38.1",
+  "version": "1.40.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/README.md

@@ -4,6 +4,7 @@ A small working method that lives in your repository: a versioned plan linked to
 waves of fresh AI sessions driven by a program, and deliveries proved by their effect.
 It is for solo developers and AI-assisted sessions who lose track of *what is left to do* and *what each commit was for*:
 cadence keeps both in plain files next to the code, and [Claude Code](https://claude.com/claude-code) skills turn it into rituals.
+New to the words (lot, wave, hold…)? [docs/concepts.md](docs/concepts.md) explains each notion, with four figures.
 
 ## Start
 
@@ -15,8 +16,7 @@ raf init
 raf add "My first lot" --estimate 1
 ```
 
-Then `raf start L1`, commit with `feat(L1): …`, `raf now` to see where you are, `raf done L1` when it is finished.
-`raf -v` prints the installed version. Every command is in [docs/raf.md](docs/raf.md).
+Then `raf start L1`, commit with `feat(L1): …`, `raf now` to see where you are, `raf done L1` when finished. Every command: [docs/raf.md](docs/raf.md).
 
 ## Lead several projects in 10 minutes
 
@@ -53,7 +53,7 @@ Details: [docs/skills.md](docs/skills.md) and [docs/cadence-hud.md](docs/cadence
 - [docs/deliver.md](docs/deliver.md): wait for the CI, deploy, verify the effect; [docs/remote-gate.md](docs/remote-gate.md): the gate on another machine.
 - [docs/spec.md](docs/spec.md): screen and back-end sheets.
 - [docs/ref.md](docs/ref.md): reference documents (specs, norms, mock-ups) and the coverage of their elements by the lots.
-- [docs/lead.md](docs/lead.md): the lead workflow, and the `livreur` agent that delivers a ready lot for it.
+- [docs/lead.md](docs/lead.md): the lead workflow, the `livreur` agent, and [the memory index warning](docs/session.md#memory-index-size-l442) (L442).
 - [docs/overview.md](docs/overview.md): the longer introduction and the map of every page; [docs/fonctionnement.md](docs/fonctionnement.md): how it works.
 - [docs/stabilite.md](docs/stabilite.md): what is guaranteed from 1.0.0; [docs/qualite.md](docs/qualite.md): the code-quality ratchet.
 - [docs/whats-new.md](docs/whats-new.md) and [CHANGELOG.md](CHANGELOG.md): what changed.

package/dist/cli.js

@@ -24,6 +24,7 @@ import { schedule } from './schedule.js';
 import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.js';
 import { configSet } from './config-set.js';
 import { movePriority } from './priority.js';
+import { closeMemoryLines, tourMemoryLines } from './memory-index.js';
 import { findProjects, isProject, readDepth, leadTour, TITLE_MAX, truncate, readLeadUx, tourFreeLine, readLeadContextThreshold, findLeadDir, tourLine, tourNoTestLines, tourWorktreeLines } from './lead.js';
 import { configuredCap, expiredHoldLines, slotsLine, orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
 import { addHold, releaseHold } from './orchestrate/registry.js';
@@ -270,7 +271,8 @@ function dispatch(argv, io) {
             for (const r of rows)
                 io.out(tourLine(r));
             // les worktrees de lot que des vagues ont conservés : aucun n'est oublié en silence (L279, R19)
-            for (const l of tourWorktreeLines(rows, io.now().getTime()))
+            // … puis l'index MEMORY.md du dossier, s'il pèse trop (L442) : le lead propose le regroupement, rien n'est écrit
+            for (const l of [...tourWorktreeLines(rows, io.now().getTime()), ...tourMemoryLines(io.env, parent)])
                 io.out(l);
             // un projet sans orchestrate.test : la vague ne lancera pas la suite (L327)
             for (const l of tourNoTestLines(rows))
@@ -779,7 +781,7 @@ function dispatch(argv, io) {
             const sconf = rest[0] === 'start' || rest[0] === 'close' ? readSessionConfig(configPath) : {};
             const facts = rest[0] === 'start' || rest[0] === 'close' ? sconf[rest[0]] : undefined;
             const clean = rest[0] === 'close' && sconf.clean ? { patterns: sconf.clean, days: sconf.cleanDays } : undefined;
-            const sctx = { plan: loadPlan(), root, newsDir, state: stateDir(root), shared: sharedStateDir(root), today, now: io.now(), out: io.out, facts, clean };
+            const sctx = { plan: loadPlan(), root, newsDir, state: stateDir(root), shared: sharedStateDir(root), today, now: io.now(), out: io.out, facts, clean, memory: closeMemoryLines(io.env, io.cwd, configPath) };
             if (rest[0] !== 'start')
                 return session(rest, sctx, values);
             // La reprise rejoue les vérifications d'effet (un essai, borné) : un effet rouge d'hier se lit avec les faits du matin.

package/dist/config-set.js

@@ -7,6 +7,7 @@ import { defaultPlan, readDocsConfig, readHookConfig, readMigrateConfig, readNew
 import { parseDeliverConfig } from './deliver.js';
 import { commitPaths, dirtyPaths, gitRoot, restorePaths } from './git.js';
 import { findProjects, isProject, readDepth, readLeadContextThreshold, readLeadUx } from './lead.js';
+import { readMemoryIndexMax } from './memory-index.js';
 import { readPriority } from './orchestrate/continue.js';
 import { Plan, RafError } from './plan.js';
 const KEY = /^[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)*$/;
@@ -25,6 +26,7 @@ export function validateConfig(file, root) {
     readDocsConfig(file);
     readReferencesConfig(file);
     readMigrateConfig(file);
+    readMemoryIndexMax(file);
     readLeadUx(dirname(file));
     readLeadContextThreshold(dirname(file));
     readDepth(dirname(file));

package/dist/cost.js

@@ -0,0 +1,40 @@
+/** Part de `counted` rangée en entrée quand une étape ne porte que ce compteur (journal ancien, ou budget d'un lot annoncé en euros) : le reste est en sortie (R8 b de L226). */
+export const COUNTED_INPUT_SHARE = 0.9;
+/** Coût en euros d'une étape (R8 de L226) ; le nom du modèle sans prix quand il en faudrait un. */
+export function stepEuros(step, prices) {
+    if (step.model === 'local')
+        return 0;
+    const usage = step.usage ?? (step.counted === undefined ? null : { input: COUNTED_INPUT_SHARE * step.counted, cacheWrite: 0, cacheRead: 0, output: (1 - COUNTED_INPUT_SHARE) * step.counted });
+    if (!usage)
+        return 0;
+    const price = step.model === 'sonnet' || step.model === 'opus' || step.model === 'haiku' ? prices[step.model] : undefined;
+    if (!price)
+        return { missing: step.model === 'sonnet' || step.model === 'opus' || step.model === 'haiku' ? step.model : 'inconnu' };
+    const n = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
+    return ((n(usage.input) + n(usage.cacheWrite)) * price.input + n(usage.output) * price.output + n(usage.cacheRead) * price.cacheRead) / 1_000_000;
+}
+/** Un montant en euros, deux décimales et virgule : `4,80 €`. */
+export const euros = (v) => `${v.toFixed(2).replace('.', ',')} €`;
+/** Coût en euros d'un lot : la somme de ses étapes ; null dès qu'une étape tourne sur un modèle sans prix dans la grille (un coût partiel serait pris pour le vrai). */
+export function sumEuros(steps, prices) {
+    let total = 0;
+    for (const s of steps) {
+        const e = stepEuros(s, prices);
+        if (typeof e !== 'number')
+            return null;
+        total += e;
+    }
+    return total;
+}
+/** Les montants d'un ensemble de lots : `total` des lots chiffrés, `unknown` = nombre de lots dont un modèle n'a pas de prix. */
+export function waveEuros(perLot) {
+    let total = 0;
+    let unknown = 0;
+    for (const e of perLot) {
+        if (e === null)
+            unknown++;
+        else
+            total += e;
+    }
+    return { total, unknown };
+}

package/dist/memory-index.js

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse } from 'yaml';
+import { RafError } from './plan.js';
+import { claudeConfigDir, projectLogDir } from './orchestrate/launch.js';
+/** Taille (octets) au-delà de laquelle l'index MEMORY.md est signalé quand `memory.indexMaxBytes` n'est pas posé (L442). */
+const MEMORY_INDEX_MAX_BYTES = 12_000;
+/** L'index de la mémoire de Claude Code du dossier `dir` (celui où la session est lancée, jamais la racine git). */
+function memoryIndexPath(env, dir) {
+    return join(projectLogDir(claudeConfigDir(env), dir), 'memory', 'MEMORY.md');
+}
+// « - », puis au plus « ** », « [ » et « ⚠ », puis un jour « jj-mm » : le nom du fichier lié ne compte pas.
+const DATED = /^- (?:\*\*)?\[?(?:⚠️?\s*)?(?:0[1-9]|[12]\d|3[01])-(?:0[1-9]|1[0-2])(?!\d)/;
+/** Les entrées datées d'un index : leur nombre et leur poids en octets (fin de ligne comprise). */
+function datedEntries(text) {
+    let count = 0;
+    let bytes = 0;
+    const lines = text.replace(/^\uFEFF/, '').split('\n');
+    for (const [i, line] of lines.entries()) {
+        const bare = line.replace(/\r$/, '');
+        if (!DATED.test(bare))
+            continue;
+        count++;
+        // la fin de ligne ne compte que si elle existe : la dernière ligne peut ne pas en avoir
+        bytes += Buffer.byteLength(line) + (i < lines.length - 1 ? 1 : 0);
+    }
+    return { count, bytes };
+}
+/** Mesure l'index : absent ou au plus égal au seuil = `ok` ; une lecture impossible se dit au lieu de lever. Ne modifie rien. */
+function checkMemoryIndex(env, dir, max) {
+    let buf;
+    try {
+        buf = readFileSync(memoryIndexPath(env, dir));
+    }
+    catch (e) {
+        const code = e.code;
+        return code === 'ENOENT' ? { kind: 'ok' } : { kind: 'unreadable', cause: e.message.split('\n')[0] };
+    }
+    if (buf.length <= max)
+        return { kind: 'ok' };
+    return { kind: 'over', size: buf.length, max, ...datedEntries(buf.toString('utf8')) };
+}
+const NO_DATED = "aucune entrée datée à regrouper dans l'index MEMORY.md";
+/** Les lignes de la section « Mémoire » de `session close`, précédée d'une ligne vide (aucune quand l'index est sain). */
+function closeLines(c) {
+    if (c.kind === 'ok')
+        return [];
+    if (c.kind === 'unreadable')
+        return [`\nMémoire : l'index MEMORY.md est illisible (${c.cause}), sa taille n'est pas contrôlée`];
+    return [
+        `\nMémoire : l'index MEMORY.md pèse ${c.size} octets (seuil ${c.max})`,
+        c.count === 0
+            ? `  ${NO_DATED}`
+            : `  ${c.count} entrée(s) datée(s) (${c.bytes} octets) à regrouper sous une ligne vers un index secondaire — le skill propose, l'humain décide`,
+    ];
+}
+function tourLines(c) {
+    if (c.kind === 'ok')
+        return [];
+    if (c.kind === 'unreadable')
+        return [`mémoire · MEMORY.md illisible (${c.cause})`];
+    const tail = c.count === 0 ? 'aucune entrée datée à regrouper' : `${c.count} entrée(s) datée(s) à regrouper (cadence session close détaille)`;
+    return [`mémoire · MEMORY.md ${c.size} octets > seuil ${c.max} · ${tail}`];
+}
+/**
+ * Clé `memory.indexMaxBytes` de cadence.yaml : seuil, en octets, de l'avertissement ; `undefined` quand elle est absente.
+ * Une valeur qui n'est pas un entier ≥ 1 est refusée.
+ */
+export function readMemoryIndexMax(file) {
+    if (!existsSync(file))
+        return undefined;
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const m = raw?.memory;
+    if (m == null)
+        return undefined;
+    if (typeof m !== 'object' || Array.isArray(m))
+        throw new RafError(`${file} : memory doit être un objet { indexMaxBytes }`);
+    for (const k of Object.keys(m))
+        if (k !== 'indexMaxBytes')
+            throw new RafError(`${file} : memory.${k} inconnu (attendu : indexMaxBytes)`);
+    const v = m.indexMaxBytes;
+    if (v === undefined)
+        return undefined;
+    if (typeof v !== 'number' || !Number.isInteger(v) || v < 1)
+        throw new RafError(`${file} : memory.indexMaxBytes doit être un entier ≥ 1 (octets), pas ${typeof v === 'object' ? JSON.stringify(v) : String(v)}`);
+    return v;
+}
+/**
+ * Pour `session close` : le contexte de la mesure, relu à l'appel (une clé invalide lève alors avant tout rapport). Le seuil vient
+ * du `cadence.yaml` que la commande lit.
+ */
+export function closeMemoryLines(env, dir, configFile) {
+    return () => closeLines(checkMemoryIndex(env, dir, readMemoryIndexMax(configFile) ?? MEMORY_INDEX_MAX_BYTES));
+}
+/**
+ * Pour `lead tour` : la ligne « mémoire » du dossier parent, avec le seuil de son cadence.yaml. Une clé invalide n'arrête pas le tour : une ligne d'erreur
+ * remplace la ligne « mémoire » ; un cadence.yaml illisible a déjà sa ligne d'erreur en tête de tour et n'en ajoute pas ici.
+ */
+export function tourMemoryLines(env, parent) {
+    try {
+        return tourLines(checkMemoryIndex(env, parent, readMemoryIndexMax(join(parent, 'cadence.yaml')) ?? MEMORY_INDEX_MAX_BYTES));
+    }
+    catch (e) {
+        const message = e.message;
+        return / : memory/.test(message) ? [`cadence.yaml · ✗ erreur : ${message.replace(/^.*cadence\.yaml : /, '')}`] : [];
+    }
+}

package/dist/orchestrate/ajout.js

@@ -77,6 +77,12 @@ export async function addToLive(args, run, store, checks) {
 export class AddFeed {
     e;
     waiting = new Map();
+    /** Les lots tirés du plan (L527) dont le dépôt était pris quand ils ont été contrôlés : gardés pour ne pas refaire le contrôle à chaque lecture. */
+    drawn = new Map();
+    /** Les lots tirés du plan (L527) que le contrôle a refusés pour eux-mêmes : écartés pour la vague, comme un lot sauté au tirage. */
+    refused = new Set();
+    /** Les causes déjà dites au journal (L527) : un refus passager (arbre sale, dépôt tenu) est relu à chaque lecture de la file mais dit une fois. */
+    said = new Set();
     constructor(e) {
         this.e = e;
     }
@@ -148,8 +154,10 @@ export class AddFeed {
         e.wave.lots.push(lotKey(c.lot.project, c.lot.lot));
         e.store.writeLot(c.lot);
         e.saveWave();
-        e.store.markAddTaken(entry.id);
-        this.waiting.delete(entry.id);
+        if (entry) {
+            e.store.markAddTaken(entry.id);
+            this.waiting.delete(entry.id);
+        }
         e.wctx.log(`${lotKey(c.lot.project, c.lot.lot)} : ajouté à la vague ${e.wave.id}`);
     }
     /** Les lots ajoutés à ce tour, prêts à être joués ; `canRun` dit si le dépôt du lot est libre (jamais deux sessions dans un même dépôt hors worktree). */
@@ -176,9 +184,86 @@ export class AddFeed {
             this.e.announce();
         return added;
     }
+    say(line) {
+        if (this.said.has(line))
+            return;
+        this.said.add(line);
+        this.e.wctx.log(line);
+    }
+    /** Le contexte d'un lot tiré du plan : celui gardé (recontrôlé : arrêt, budget, lot fini) ou celui que le contrôle préalable construit ; null quand il est refusé ou ne tient pas (L527). */
+    async control(t, key, badRepos, room) {
+        const e = this.e;
+        const kept = this.drawn.get(key);
+        if (kept) {
+            if (kept.lot.budget <= Math.min(e.budgetLeft(), room) && !e.planState(kept))
+                return kept;
+            this.drawn.delete(key);
+            return null;
+        }
+        const known = [...e.ctxs, ...this.waiting.values()].map((x) => ({ project: x.lot.project, lot: x.lot.lot }));
+        const built = await e.build(t, known);
+        if ('refusals' in built) {
+            // Un refus propre au lot l'écarte pour la vague ; celui du dépôt (arbre sale, orchestration en cours) est passager : le lot est relu à la lecture suivante.
+            if (built.refusals.some((r) => r.startsWith(`${key} : `)))
+                this.refused.add(key);
+            else
+                badRepos.add(t.repo); // les autres lots de ce dépôt buteraient sur la même cause, ce tour-ci
+            for (const r of built.refusals)
+                this.say(`continue : lot sauté — ${r}`);
+            return null;
+        }
+        return built.ctx.lot.budget <= Math.min(e.budgetLeft(), room) ? built.ctx : null;
+    }
+    /**
+     * L527 : remplit au plus `free` créneaux libres avec les lots prêts du plan (`plan.targets`, déjà dans l'ordre de priorité et filtrés sur les ressources libres), chacun contrôlé comme un lot ajouté.
+     * Ce qu'un lot pris engage est décompté avant le suivant : son budget du `plan.room`, ses ressources `uses` (un lot qui veut une ressource que ce remplissage vient de prendre attend la lecture suivante).
+     * Un lot dont le dépôt est pris par un lot qui joue (`canRun`) est gardé pour la lecture suivante, le lot d'un autre dépôt passe devant ; un lot refusé est sauté pour la vague, dit au journal ;
+     * un lot que le budget restant ne tient pas n'est ni pris ni écarté (un moins cher peut passer, ou le tour suivant).
+     */
+    async fill(plan, free, canRun) {
+        const e = this.e;
+        const added = [];
+        const badRepos = new Set();
+        const taken = new Set();
+        let room = plan.room;
+        for (const t of plan.targets) {
+            if (added.length >= free || e.stopCause())
+                break;
+            const key = lotKey(t.project, t.lot);
+            if (this.refused.has(key) || badRepos.has(t.repo) || t.uses.some((r) => taken.has(r)))
+                continue;
+            const c = await this.control(t, key, badRepos, room);
+            if (!c || !this.start(key, c, canRun))
+                continue;
+            added.push(c);
+            room -= c.lot.budget;
+            for (const r of t.uses)
+                taken.add(r);
+        }
+        if (added.length)
+            e.announce();
+        return added;
+    }
+    /** Prend le lot contrôlé `c` : faux quand le dépôt est pris (gardé pour la lecture suivante) ou que la prise est refusée (sauté, dit au journal). */
+    start(key, c, canRun) {
+        if (!canRun(c)) {
+            this.drawn.set(key, c);
+            return false;
+        }
+        this.drawn.delete(key);
+        const refused = this.holdAll(c);
+        if (refused) {
+            this.say(`continue : lot sauté — ${key} : ${refused}`);
+            return false;
+        }
+        this.e.wctx.log(`continue : tire ${key} (créneau libre)`);
+        this.admit(null, c);
+        return true;
+    }
     /** Les demandes encore en file quand plus rien ne joue ne seront plus lues : écartées et dites. */
     drain(why) {
         this.waiting.clear();
+        this.drawn.clear();
         for (const entry of this.e.store.addQueue())
             this.discard(entry, why);
     }

package/dist/orchestrate/command.js

@@ -26,7 +26,7 @@ import { ficheReviewText } from './fiche.js';
 import { maquetteText } from './maquette.js';
 import { costlyHypotheses, specScreen, specText } from './spec.js';
 import { fichesDuDossier } from '../spec.js';
-import { candidates, parsePriority, parseUntil, drawSettingsReport, readPriority, stopReason } from './continue.js';
+import { candidates, fillTargets, handedBackStreak, parsePriority, parseUntil, drawSettingsReport, readPriority, stopReason } from './continue.js';
 import { precheckNothingToFind, Budget, ESCALATION_RESERVE, DROPPED, STOP_REQUESTED, MAX_PASSES, REVIEW_RESERVE, budgetStep, heldForEscalation, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, planNoteHandBack, leadReviewedHandBack, HYPOTHESES_HANDBACK, handBackDroppedQuestions, needsPrecheck, workDir } from './cycle.js';
 import { installPrePush, keepGateGuard, longDuration, removePrePush } from './guard.js';
 import { buildArgs, buildLocalArgs, killSessions, MODEL_ALIASES, mcpServersFor, readAgents, realClaude, enabledPlugins, settingsFiles } from './launch.js';
@@ -42,7 +42,7 @@ import { resolveLotRepos } from '../repos.js';
 import { excludeState, lotFinished, lotKey, lotRepoPaths, lotSlug, neighbourDirs, newLot, RunStore } from './state.js';
 import { isExpress } from './express.js';
 import { linkNodeBin, nvmVersionsDir, resolveNode } from './node-env.js';
-import { quotaText, renderDetail, renderTable, resumeCommand } from './table.js';
+import { estimateLines, launchPrices, quotaText, renderDetail, renderTable, resumeCommand } from './table.js';
 import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveModulesDir, repairSnapshotModules, snapshotExists, waveReadsAnswerQueue, waveReadsControl, waveReadsIntegrate, waveReadsLotBudget, waveReadsReplay, withoutLaunchVars, spawnReexec, takeSnapshot, toolDirOf } from './snapshot.js';
 const REPO_WAIT_MS = 3 * 60 * 60_000;
 const REPO_WAIT_POLL_MS = 5_000;
@@ -424,7 +424,8 @@ function planMessageLines(repo, l, wave, dir) {
         `  ✗ 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})`,
     ];
 }
-function dryRun(lots, io, deps, budget, id) {
+/** `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). */
+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)`);
@@ -443,7 +444,7 @@ function dryRun(lots, io, deps, budget, id) {
             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, l.screen ? 'screen' : l.specLot ? 'spec' : undefined, l.escalationReserve ? env.config.escalation?.model : undefined)})`);
         const mine = lots.filter((o) => o.repo === l.repo);
-        const together = env.config.worktrees && mine.length > 1 && !mine.some((o) => o.repos?.length) && !!repoBranch(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})`);
@@ -615,7 +616,7 @@ function statusView(args, launch, cap, now) {
             throw new RafError(e.message);
         }
     }
-    return { live, table: [...renderTable(store.readWave(), lots, { compact: true }), ...keptLines(lots.map((l) => l.repo), now.getTime())], running };
+    return { live, table: [...renderTable(store.readWave(), lots, { compact: true, prices: launchPrices(launch, (w) => live.push(`⚠ ${w}`)) }), ...keptLines(lots.map((l) => l.repo), now.getTime())], running };
 }
 /** La vague que `--status` suit (L395) : `--status <id>` ou `--status --wave <id>` ; aucune : la dernière du dossier. Deux ids différents : refus. */
 function statusWave(args) {
@@ -766,10 +767,9 @@ export async function orchestrate(argv, io, deps) {
         const id = waveId(io, args.wave, launch);
         if (args.wave && existsSync(join(RunStore.runsDir(launch), id)))
             return waveExists(args.wave, io);
-        dryRun(pre.lots, io, deps, budget, id);
-        if (args.continue)
-            for (const l of freeLines(launch, pre.lots))
-                io.out(l);
+        dryRun(pre.lots, io, deps, { budget, id, multiSlot: maxSessions(args, io) > 1 });
+        for (const l of [...estimateLines(pre.lots, launch, (w) => io.err(`orchestrate : ${w}`)), ...(args.continue ? freeLines(launch, pre.lots) : [])])
+            io.out(l);
         if (args.continue)
             await continueDryRun(args, io, deps, launch, pre.lots, budget, firstSkipped);
         return 0;
@@ -831,7 +831,7 @@ export async function orchestrate(argv, io, deps) {
                 l.node.link = (deps.linkNode ?? linkNodeBin)(store.dir, l.node.version, l.node.bin);
             store.writeLot(l);
         }
-        const code = await continueRounds(await execute(wave, pre.lots, store, io, deps, today, maxSessions(args, io)), wave, pre.lots, store, io, deps, today, args, launch);
+        const code = await continueRounds(await execute(wave, pre.lots, store, io, deps, today, args), wave, pre.lots, store, io, deps, today, args, launch);
         abandon();
         return code;
     }
@@ -899,11 +899,13 @@ async function draw(args, io, deps, launch, exclude, remaining, n) {
     return { lots, skipped };
 }
 /** Nombre de tours que la simulation de `--dry-run --continue` déroule au plus. */
-const DRY_RUN_ROUNDS = 10;
+/** Le plus de lots que `--dry-run --continue` liste après le premier tirage. */
+const DRY_RUN_LOTS = 10;
 /**
- * `--dry-run --continue` : ce que les tirages suivants joueraient, par tour, avec la même fonction `draw` que la vague (un lot par dépôt
- * par tour, contrôle préalable, budget) ; 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). `firstSkipped` : causes écartées au premier tirage, quand il a fourni les lots donnés.
+ * `--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.
  */
 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}` : ''}`);
@@ -921,28 +923,17 @@ async function continueDryRun(args, io, deps, launch, given, budget, firstSkippe
     for (const line of drawSettingsReport(launch, exclude))
         io.out(`  ${line}`);
     let remaining = budget - given.reduce((sum, l) => sum + (l.budget ?? 0), 0);
-    const cap = maxSessions(args, io);
-    const rounds = [];
-    for (let round = 1; round <= DRY_RUN_ROUNDS && remaining > 0; round++) {
-        const drawn = await draw(args, io, deps, launch, exclude, remaining, cap);
+    const next = [];
+    while (next.length < DRY_RUN_LOTS && remaining > 0) {
+        const drawn = await draw(args, io, deps, launch, exclude, remaining, 1);
         skip(drawn.skipped);
-        if (drawn.lots.length === 0)
+        const lot = drawn.lots[0];
+        if (!lot)
             break;
-        rounds.push(`tour ${round} : ${drawn.lots.map((l) => lotKey(l.project, l.lot)).join(', ')}`);
-        remaining -= drawn.lots.reduce((sum, l) => sum + (l.budget ?? 0), 0);
+        next.push(lotKey(lot.project, lot.lot));
+        remaining -= lot.budget ?? 0;
     }
-    io.out(rounds.length ? `  tirés ensuite, par tour (budget décompté sur les estimations) : ${rounds.join(' · ')}${rounds.length === DRY_RUN_ROUNDS ? ' · …' : ''}` : '  aucun autre lot prêt à tirer');
-}
-/** Lots rendus ou en échec de suite, en comptant depuis le dernier lot de la vague. */
-function handedBackStreak(all) {
-    let n = 0;
-    for (const l of [...all].reverse()) {
-        if (l.status === 'handed-back' || l.status === 'failed')
-            n++;
-        else
-            break;
-    }
-    return n;
+    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');
 }
 /**
  * `--continue` (L147) : tant qu'aucune borne ne joue, tire jusqu'à `cap` lots prêts du plan et les joue dans la même vague
@@ -985,7 +976,7 @@ async function continueRounds(first, wave, all, store, io, deps, today, args, la
         store.writeWave(wave);
         all.push(...drawn.lots);
         say(`continue : tire ${drawn.lots.map((l) => lotKey(l.project, l.lot)).join(', ')}`);
-        code = await execute(wave, drawn.lots, store, io, deps, today, cap, all);
+        code = await execute(wave, drawn.lots, store, io, deps, today, args, all);
         if (code === 2)
             return code;
     }
@@ -994,16 +985,16 @@ function contexts(lots, envs, wctx) {
     return lots.map((lot, i) => ({ wave: wctx, lot, config: envs[i].config, loadPlan: envs[i].loadPlan }));
 }
 /**
- * Quels lots jouent dans un worktree (L279). Un groupe de lots du même dépôt (`groupLots`) y joue si `orchestrate.worktrees` est vrai, s'il a au moins deux lots,
- * si le dépôt est sur une branche et si aucun de ses lots n'a de dépôt voisin (`repos:`, R2) ; sinon les lots restent à la suite, avec un avertissement qui dit pourquoi.
+ * Quels lots jouent dans un worktree (L279). Un groupe de lots du même dépôt (`groupLots`) y joue si `orchestrate.worktrees` est vrai, s'il a au moins deux lots
+ * ou si la vague a plus d'un créneau (`multiSlot`, L527 : tout lot d'un tel dépôt reçoit son worktree — donné seul, tiré par le remplissage ou apporté par `--add`, avec ou sans `--continue` — pour qu'un créneau libre reçoive le lot suivant du même dépôt), si le dépôt est sur une branche et si aucun de ses lots n'a de dépôt voisin (`repos:`, R2) ; sinon les lots restent à la suite, avec un avertissement qui dit pourquoi.
  * Un lot dont la branche existe déjà (reprise, R11) retrouve son worktree quel que soit le groupe ; un lot rendu à l'intégration dont la branche a disparu n'en reçoit pas. La branche de départ est celle du dépôt du lead à cet instant,
  * ou celle que la branche du lot a notée à sa création.
  */
-function planTrees(ctxs, store, wave, log) {
+function planTrees(ctxs, store, wave, log, multiSlot) {
     for (const group of groupLots(ctxs)) {
         const repo = group[0].lot.repo;
         const branch = repoBranch(repo);
-        const requested = group.length > 1 && group.every((c) => c.config.worktrees);
+        const requested = (group.length > 1 || multiSlot) && group.every((c) => c.config.worktrees);
         const why = !requested ? null : group.some((c) => c.lot.repos?.length) ? 'des lots du groupe ont des dépôts voisins (repos:)' : !branch ? 'le dépôt est en HEAD détaché' : null;
         if (why)
             log(`orchestrate : ${basename(repo)} : worktrees demandés mais ${why} : lots joués à la suite`);
@@ -1035,7 +1026,8 @@ function planTrees(ctxs, store, wave, log) {
     }
 }
 /** Pose les verrous et les hooks, joue la vague, range l'état, rend le tableau et le code de sortie. */
-async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
+async function execute(wave, lots, store, io, deps, today, args, all = lots) {
+    const cap = maxSessions(args, io);
     const launch = store.launchDir;
     // La configuration des projets est lue avant de poser quoi que ce soit : un cadence.yaml illisible ne laisse ni verrou ni hook.
     const envs = lots.map((lot) => projectEnv(lot.repo));
@@ -1168,7 +1160,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
     wave.pid = process.pid;
     saveWave();
     const ctxs = contexts(lots, envs, wctx);
-    planTrees(ctxs, store, wave.id, wctx.log);
+    planTrees(ctxs, store, wave.id, wctx.log, cap > 1);
     try {
         updateWaveRepos(home, process.pid, repos, lanes());
     }
@@ -1189,7 +1181,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
             }
         },
         announce: () => updateWaveReposSafe(home, repos.filter((x) => !freed.has(x)), lanes()),
-        build: (t, known) => buildAdd(t, known, { wave: wave.id, ctxs, wctx, store, io, deps, launch }),
+        build: (t, known) => buildAdd(t, known, { wave: wave.id, ctxs, wctx, store, io, deps, launch, multiSlot: cap > 1 }),
     });
     // Ctrl-C, SIGTERM : les sessions sont tuées en bloc, les étapes marquées interrompues, les verrous et hooks libérés.
     const forget = onTermination(async () => {
@@ -1219,6 +1211,8 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         release();
     });
     const finished = lotFinished;
+    /** L527 : les lots prêts du plan que le créneau libre peut recevoir (rien sans `--continue`) ; `adds.fill` les contrôle et les prend. */
+    const refill = async (canRun, free) => args.continue && free > 0 ? adds.fill(fillTargets({ args, io, launch, home, store, all, budget, quotaHit: wctx.quota.hit, incident: !!wctx.incident }), free, canRun) : [];
     try {
         await runPool(ctxs, cap, all, (c) => {
             // Un lot rendu ou en échec garde son worktree et sa branche (R12) : le journal en donne le chemin.
@@ -1244,7 +1238,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         }, (lots) => lots.every((c) => c.tree), {
             pollMs: deps.slotPollMs ?? ANSWER_POLL_MS,
             // L407 : les réponses déposées par `--answer` pendant la vague sont prises entre deux étapes ; un lot qui n'est plus en question ne rejoue rien.
-            take: async (canRun) => {
+            take: async (canRun, free) => {
                 const taken = [];
                 for (const e of store.answerQueue()) {
                     const c = ctxs.find((x) => lotKey(x.lot.project, x.lot.lot) === e.lot);
@@ -1273,7 +1267,8 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
                         // registre illisible : le décompte reste celui du dernier écrit
                     }
                 }
-                return [...taken, ...(await adds.take(canRun))];
+                const added = await adds.take(canRun);
+                return [...taken, ...added, ...(await refill(canRun, free - taken.length - added.length))];
             },
         });
         // L421 : un ajout encore en file quand plus rien ne joue ne sera plus lu : écarté et dit.
@@ -1291,7 +1286,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         io.err(`orchestrate : incident — ${wctx.incident}`);
     if (wctx.quota.hit)
         io.err(`orchestrate : quota atteint — ${quotaText(wctx.quota.message ?? '')}`.trim());
-    for (const line of renderTable(wave, all))
+    for (const line of renderTable(wave, all, { prices: launchPrices(launch, (w) => io.err(`orchestrate : ${w}`)) }))
         io.out(line);
     for (const line of keptLines(all.map((l) => l.repo)))
         io.out(line); // les worktrees conservés, avec leur chemin (R19)
@@ -1344,8 +1339,8 @@ async function addOnlyLive(args, io, deps, launch) {
     return typeof store === 'number' ? store : addToLive(args, { io, deps, launch }, store, LAUNCH_CHECKS);
 }
 /**
- * Le contexte d'un lot ajouté en cours de vague (L421) : le contrôle préalable d'un lot de lancement (les lots de la vague comptent pour les dépendances), le lien du Node,
- * puis un worktree seulement si tous les lots encore à jouer de son dépôt y sont aussi ; sinon il attend la fin de ceux qui jouent dans l'arbre du dépôt.
+ * Le contexte d'un lot ajouté en cours de vague (L421) ou tiré par le remplissage d'un créneau libre (L527) : le contrôle préalable d'un lot de lancement (les lots de la vague comptent pour les dépendances), le lien du Node,
+ * puis un worktree si son dépôt est en `worktrees: true` et la vague a plus d'un créneau (`multiSlot`), ou si tous les lots encore à jouer de son dépôt y sont ; sinon il attend la fin de ceux qui jouent dans l'arbre du dépôt.
  */
 async function buildAdd(t, known, w) {
     const pre = await LAUNCH_CHECKS.preflight([t], w, { wave: w.wave, lots: known });
@@ -1356,7 +1351,7 @@ async function buildAdd(t, known, w) {
         lot.node.link = (w.deps.linkNode ?? linkNodeBin)(w.store.dir, lot.node.version, lot.node.bin);
     const ctx = contexts([lot], [projectEnv(lot.repo)], w.wctx)[0];
     const open = openInRepo(w.ctxs, ctx);
-    planTrees(open.every((o) => o.tree) ? [...open, ctx] : [ctx], w.store, w.wave, w.wctx.log);
+    planTrees(open.every((o) => o.tree) ? [...open, ctx] : [ctx], w.store, w.wave, w.wctx.log, w.multiSlot);
     return { ctx };
 }
 /** Le registre des vagues vivantes : dépôts tenus et créneaux occupés ; illisible, le décompte reste celui du dernier écrit. */
@@ -1797,14 +1792,14 @@ async function resume(args, argv, io, deps, launch, today) {
                 wave.status = 'done';
                 store.writeWave(wave);
             }
-            for (const line of renderTable(wave, lots))
+            for (const line of renderTable(wave, lots, { prices: launchPrices(launch, (w) => io.err(`orchestrate : ${w}`)) }))
                 io.out(line);
             for (const line of keptLines(lots.map((l) => l.repo)))
                 io.out(line);
             return removed.length && !lots.every((l) => l.status === 'ready') ? 1 : 0;
         }
         played = true;
-        return continueRounds(await execute(wave, live, store, io, deps, today, maxSessions(args, io), lots), wave, lots, store, io, deps, today, args, launch);
+        return continueRounds(await execute(wave, live, store, io, deps, today, args, lots), wave, lots, store, io, deps, today, args, launch);
     }
     finally {
         if (!played)