@sylad/cadence 1.42.1 → 1.43.0

package/dist/orchestrate/status.js

@@ -0,0 +1,264 @@
+import { basename } from 'node:path';
+import { gitRoot } from '../git.js';
+import { localOverdueLines } from '../local-task.js';
+import { RafError } from '../plan.js';
+import { findProjects, isProject as isLeadProject } from '../lead.js';
+import { freeLine, readyFree } from '../ready-free.js';
+import { cadenceHome, expiredHolds, freeSlots, liveHolds, liveSlots, liveWaves } from './registry.js';
+import { longDuration } from './guard.js';
+import { keptLines } from './worktree.js';
+import { lotFinished, lotKey, RunStore } from './state.js';
+import { launchPrices, renderDetail, renderTable, resumeCommand } from './table.js';
+import { waveReadsAnswerQueue, waveReadsControl } from './snapshot.js';
+import { DEFAULT_MAX_SESSIONS, parseMaxSessions } from './command-args.js';
+export function maxSessions(args, io) {
+    if (args.maxSessions !== undefined)
+        return args.maxSessions;
+    const env = io.env.CADENCE_MAX_SESSIONS;
+    return env ? parseMaxSessions(env, 'CADENCE_MAX_SESSIONS') : DEFAULT_MAX_SESSIONS;
+}
+/** Plafond à AFFICHER (`--status`, `lead tour`) : le réglage de l'humain, jamais 2 en dur. Un réglage invalide ne casse pas l'affichage (le lancement, lui, le refuse) : retour au défaut. */
+export function configuredCap(env, flag) {
+    if (flag !== undefined)
+        return flag;
+    try {
+        return env.CADENCE_MAX_SESSIONS ? parseMaxSessions(env.CADENCE_MAX_SESSIONS, 'CADENCE_MAX_SESSIONS') : DEFAULT_MAX_SESSIONS;
+    }
+    catch {
+        return DEFAULT_MAX_SESSIONS;
+    }
+}
+export function duration(ms) {
+    const s = Math.round(ms / 1000);
+    return s < 60 ? `${s} s` : `${Math.floor(s / 60)} min ${String(s % 60).padStart(2, '0')} s`;
+}
+/** La ligne des créneaux (L141, L255) et leur nombre libre : toujours, même sans vague ni session du lead (L416 : « libres : 3 sur 3 » se lit, il ne se déduit pas d'une absence de ligne). */
+export function slotsLine(cap = DEFAULT_MAX_SESSIONS, now = new Date()) {
+    const home = cadenceHome();
+    const holds = liveHolds(home, now);
+    const free = freeSlots(liveWaves(home), cap, holds.length);
+    const lead = holds.length ? ` · sessions du lead : ${holds.length} (${holds.map((h) => h.label).join(', ')})` : '';
+    return { line: `vagues en cours : ${liveWaves(home).length} · sessions en cours : ${liveSlots(home).length}${lead} · créneaux libres : ${free} sur ${cap}`, free };
+}
+/** Vagues vivantes (toutes, quel que soit leur dossier de départ), sessions du lead (L255), créneaux libres et dépôts qu'elles tiennent. Rien sans vague ni session du lead. */
+export function liveLines(cap = DEFAULT_MAX_SESSIONS, now = new Date()) {
+    const home = cadenceHome();
+    const waves = liveWaves(home);
+    if (waves.length === 0 && liveHolds(home, now).length === 0)
+        return [];
+    const lines = [slotsLine(cap, now).line];
+    for (const w of waves)
+        lines.push(`  ${w.wave} (pid ${w.pid}, depuis ${w.started}) lancée depuis ${w.cwd} · plafond ${w.cap ?? '?'} · dépôts : ${w.repos.join(', ')}`);
+    return lines;
+}
+/** Une ligne ⚠ par session du lead dont le TTL est échu et qui n'a pas été rendue (L278) : vide sans session échue. */
+export function expiredHoldLines(now = new Date()) {
+    return expiredHolds(cadenceHome(), now).map((h) => {
+        const since = Date.parse(h.since);
+        const age = Number.isFinite(since) ? `inscrite depuis ${longDuration(now.getTime() - since)}, ` : '';
+        return `⚠ session du lead échue : ${h.label} (${age}échue depuis ${longDuration(now.getTime() - Date.parse(h.expires))}) — la reprendre (cadence lead hold ${h.label} --ttl <minutes>) ou l'arrêter (cadence lead release ${h.label})`;
+    });
+}
+/** `--continue` (L252) : la ligne des lots prêts dont aucune ressource n'est prise par un lot en cours ni par une vague, sans les lots du premier tirage `drawn` ni les ressources qu'ils tiennent. Vide si aucun. */
+export function freeLines(launch, drawn) {
+    const dirs = isLeadProject(launch) ? [launch] : findProjects(launch);
+    const free = readyFree(dirs, cadenceHome(), drawn);
+    const line = freeLine(dirs.filter((d) => free.has(d)).map((d) => ({ project: basename(d), free: free.get(d) })), 60);
+    return line ? [line] : [];
+}
+/** Efface l'écran et replace le curseur en haut : l'entrée d'un rendu de `--status --watch`. */
+const CLEAR_SCREEN = '\x1b[H\x1b[2J';
+const DEFAULT_WATCH_INTERVAL = 10;
+/** Ce que `--status` montre à un instant : les vagues vivantes, puis le tableau (absent si seules les vagues vivantes comptent). */
+function statusView(args, launch, cap, now) {
+    const id = statusWave(args);
+    const store = id !== undefined ? RunStore.find(launch, id) : RunStore.last(launch);
+    const live = [...liveLines(cap, now), ...expiredHoldLines(now), ...localOverdueLines((isLeadProject(launch) ? [launch] : findProjects(launch)).map((d) => gitRoot(d) ?? d), now)];
+    const waveLive = liveWaves(cadenceHome()).length > 0;
+    if (!store && live.length && id === undefined)
+        return { live, running: waveLive };
+    if (!store)
+        throw new RafError(id !== undefined ? `vague inconnue : ${id}` : 'aucune vague dans ce dossier');
+    // `running` : la vague suivie tourne — pour un <id> explicite, elle seule compte, pas les autres vagues de la machine
+    const running = id !== undefined ? liveWaves(cadenceHome()).some((w) => w.wave === store.readWave().id) : waveLive;
+    const lots = store.lots();
+    if (args.detail !== undefined) {
+        try {
+            return { live: [], table: renderDetail(lots, args.detail), running };
+        }
+        catch (e) {
+            throw new RafError(e.message);
+        }
+    }
+    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) {
+    if (typeof args.status === 'string' && args.wave !== undefined && args.status !== args.wave)
+        throw new RafError(`--status ${args.status} et --wave ${args.wave} désignent deux vagues : une seule`);
+    return typeof args.status === 'string' ? args.status : args.status === true ? args.wave : undefined;
+}
+/** Refus d'une `--wave` déjà existante, identique en simulation et au vrai lancement. */
+export function waveExists(wave, io) {
+    io.err(`orchestrate : --wave ${wave} : cette vague existe déjà`);
+    return 2;
+}
+/** L382 : `claude auth status` peut durer jusqu'à 20 s ; en --continue, preflight() le relancerait pour chaque lot candidat de chaque tour. Une seule lecture par lancement (une vague). */
+export function onceAuth(deps) {
+    const read = deps.claudeAuth;
+    if (!read)
+        return deps;
+    let cached;
+    return { ...deps, claudeAuth: () => (cached ??= { value: read() }).value };
+}
+/** `--status` (L395) : le tableau des vagues vivantes et de la vague suivie, une fois ou rafraîchi avec `--watch` jusqu'à ce que plus rien ne tourne. */
+export async function statusCommand(args, io, deps, launch) {
+    maxSessions(args, io); // une valeur invalide est refusée ici aussi
+    const view = () => statusView(args, launch, configuredCap(io.env, args.maxSessions), io.now());
+    if (!args.watch) {
+        const { live, table } = view();
+        printStatus(io, live, table); // sans identifiant (pas de tableau) : les vagues vivantes suffisent
+        return 0;
+    }
+    // --watch : le même tableau, rafraîchi ; il s'arrête seul quand plus aucune vague ne tourne (le dernier rendu reste affiché)
+    const sleep = deps.watchSleep ?? ((ms) => new Promise((res) => setTimeout(res, ms)));
+    const seconds = args.interval ?? DEFAULT_WATCH_INTERVAL;
+    for (;;) {
+        const { live, table, running } = view();
+        io.out(CLEAR_SCREEN);
+        printStatus(io, live, table);
+        if (!running)
+            return 0;
+        io.out('');
+        io.out(`rafraîchi toutes les ${seconds} s — Ctrl-C pour quitter`);
+        await sleep(seconds * 1000);
+    }
+}
+/** Les vagues vivantes, puis (s'il y en a un) le tableau de la vague suivie, séparés d'une ligne vide. */
+function printStatus(io, live, table) {
+    for (const line of live)
+        io.out(line);
+    if (!table)
+        return;
+    if (live.length)
+        io.out('');
+    for (const line of table)
+        io.out(line);
+}
+/**
+ * `--answer` sur une vague VIVANTE (L407) : la réponse est déposée dans la file de la vague (`answers.log`), qui la prend entre deux étapes et rejoue le lot dès qu'un créneau est libre.
+ * Sans cela le lead attendait la fin de la vague (15 min d'un lot bloqué le 28-10). Les lots visés sont contrôlés comme à la reprise : connus, en question.
+ */
+export function answerLive(args, io, store) {
+    const lots = store.lots();
+    const refusals = [];
+    const keys = [];
+    for (const a of args.answers) {
+        const matches = lots.filter((l) => l.lot === a.lot && (a.project ? l.project === a.project : true));
+        const where = `${a.project ? `${a.project}:` : ''}${a.lot}`;
+        if (matches.length !== 1)
+            refusals.push(matches.length ? `--answer ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--answer ${where} : lot inconnu dans la vague ${store.id}`);
+        else if (matches[0].status !== 'question')
+            refusals.push(`--answer ${lotKey(matches[0].project, matches[0].lot)} : le lot n'attend pas de réponse (${matches[0].status})`);
+        else
+            keys.push({ key: lotKey(matches[0].project, matches[0].lot), text: a.text });
+    }
+    if (!waveReadsAnswerQueue(store.dir))
+        refusals.push(`la vague ${store.id} ne lit pas la file de réponses (lancée avec une version de cadence d'avant L407) : attendre sa fin, puis ${resumeCommand(store.id, '--answer', '<projet>:<lot>', '"…"')}`);
+    if (refusals.length) {
+        for (const r of refusals)
+            io.err(`orchestrate : ${r}`);
+        return 2;
+    }
+    for (const { key, text } of keys) {
+        const id = store.requestAnswer(key, text);
+        // La vague a pu finir entre le contrôle et le dépôt : sa file ne sera plus lue, la réponse est retirée et le lead reprend à la main.
+        if (!liveWaves(cadenceHome()).some((w) => w.wave === store.id)) {
+            store.markAnswerTaken(id);
+            io.err(`orchestrate : ${key} : la vague ${store.id} vient de finir, réponse non prise : ${resumeCommand(store.id, '--answer', key, '"…"')}`);
+            return 2;
+        }
+        store.journal(`demande : réponse du lead pour ${key}`);
+        io.out(`${key} : réponse déposée — la vague ${store.id} la prend entre deux étapes et rejoue le lot dès qu'un créneau est libre`);
+    }
+    return 0;
+}
+/** La vague vivante, pour `--answer` seul (sans --resume) : la même recherche que `--drop`. */
+export function answerOnly(args, io) {
+    if (args.drop.length || args.stopAfterCurrent || args.budget !== undefined || args.dryRun || args.continue || args.lots.length)
+        throw new RafError("--answer ne se combine pas avec --drop, --stop-after-current, --budget, --dry-run, --continue ni des lots à lancer (sur une vague arrêtée : --resume --answer)");
+    const store = liveStore('--answer', args, io);
+    if (typeof store === 'number') {
+        io.err(`orchestrate : --answer : une vague arrêtée se reprend avec ${resumeCommand('<vague>', '--answer', '<projet>:<lot>', '"…"')}`);
+        return store;
+    }
+    return answerLive(args, io, store);
+}
+/** La vague vivante lancée depuis ce dossier que vise `--wave` (ou la seule) ; sinon le refus (code 2) déjà écrit. */
+export function liveStore(flags, args, io) {
+    const live = liveWaves(cadenceHome()).filter((w) => w.cwd === io.cwd && (args.wave === undefined || w.wave === args.wave));
+    if (live.length === 0) {
+        io.err(`orchestrate : ${flags} : aucune vague en cours${args.wave ? ` (${args.wave})` : ''} lancée depuis ce dossier`);
+        return 2;
+    }
+    if (live.length > 1) {
+        io.err(`orchestrate : ${flags} : plusieurs vagues tournent depuis ce dossier (${live.map((w) => w.wave).join(', ')}) : précisez --wave`);
+        return 2;
+    }
+    const store = RunStore.find(io.cwd, live[0].wave);
+    if (!store) {
+        io.err(`orchestrate : ${flags} : dossier d'état de la vague ${live[0].wave} introuvable`);
+        return 2;
+    }
+    return store;
+}
+/** `--drop` / `--stop-after-current` (L79) : une demande écrite dans le dossier d'état de la vague vivante ; c'est elle qui la lit avant sa prochaine session. */
+export function control(args, io) {
+    const flags = '--drop / --stop-after-current';
+    if (args.lots.length || args.continue || args.dryRun || args.budget !== undefined || args.answers.length)
+        throw new RafError(`${flags} ne se combinent pas avec des lots à lancer, --continue, --dry-run, --budget ou --answer`);
+    const store = liveStore(flags, args, io);
+    if (typeof store === 'number')
+        return store;
+    const lots = store.lots();
+    const refusals = [];
+    const keys = [];
+    for (const d of args.drop) {
+        const matches = lots.filter((l) => l.lot === d.lot && (d.project ? l.project === d.project : true));
+        const where = `${d.project ? `${d.project}:` : ''}${d.lot}`;
+        if (matches.length !== 1)
+            refusals.push(matches.length ? `--drop ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--drop ${where} : lot inconnu dans la vague ${store.id}`);
+        else if (lotFinished(matches[0]))
+            refusals.push(`--drop ${lotKey(matches[0].project, matches[0].lot)} : le lot est déjà fini (${matches[0].status})`);
+        else
+            keys.push(lotKey(matches[0].project, matches[0].lot));
+    }
+    if (refusals.length) {
+        for (const r of refusals)
+            io.err(`orchestrate : ${r}`);
+        return 2;
+    }
+    // La demande est écrite quoi qu'il arrive (le fichier est inoffensif) ; mais une vague d'avant L79 ne le lira jamais : on le dit.
+    if (!waveReadsControl(store.dir))
+        io.err(`orchestrate : ${flags} : la vague ${store.id} ne lit pas les demandes de contrôle (lancée avec une version de cadence d'avant L79) : la demande est écrite dans control.log mais cette vague ne la lira pas`);
+    for (const k of keys) {
+        store.requestDrop(k);
+        store.journal(`demande : retirer ${k} de la vague`);
+        io.out(`${k} : retrait demandé — la vague ${store.id} l'écarte avant sa prochaine session (la session en cours finit)`);
+    }
+    if (args.stopAfterCurrent) {
+        store.requestStopAfterCurrent();
+        store.journal('demande : arrêt après les sessions en cours');
+        io.out(`vague ${store.id} : arrêt demandé — les sessions en cours finissent, aucune autre ne part ; reprise par « ${resumeCommand(store.id)} »`);
+    }
+    return 0;
+}
+/** La seule vague non terminée du dossier (L309) ; plusieurs : refus qui les liste, aucune : refus (jamais le choix silencieux de la plus récente). */
+export function singleUnfinished(launch) {
+    const open = RunStore.unfinished(launch);
+    if (open.length === 0)
+        throw new RafError('aucune vague à reprendre dans ce dossier');
+    if (open.length > 1)
+        throw new RafError(`plusieurs vagues non terminées dans ce dossier, laquelle reprendre ?\n${open.map((s) => `  ${s.id} (${s.readWave()?.status ?? 'illisible'}, lancée ${s.readWave()?.created ?? '?'})`).join('\n')}\nreprise : ${resumeCommand('<vague>')}`);
+    return open[0];
+}

package/docs/orchestrate.md

@@ -531,7 +531,7 @@ suspended, except for such a visible lot, where the UX session needs budget and
 **Choices, not questions**: the author brief tells the session to decide minor interpretation questions itself and to list them under `choix` in its report; the reviewer receives that list to re-read, and the final table prints each one (`choix fait : …`); `--status` does not (L441: its table is compact, one line per lot, and ends with one line naming the lots that have a detail) — `--status --detail <project:lot>` prints them. A session stops with a question only on a real blocker: a decision that changes the scope or the architecture or is costly to undo, AND that the plan, its notes and CLAUDE.md do not settle; everything else is a choice.
 
 **Frozen copy of the tool (L61)**: at the real start of a wave (not with `--dry-run` or `--status`), cadence copies the
-parts of its package that run the wave (`bin/`, `dist/`, `templates/`, `agents/`, `skills/`, `package.json`; `node_modules`
+parts of its package that run the wave (`bin/`, `dist/`, `templates/`, `agents/`, `skills/`, `scripts/qualite.mjs` and its `.d.mts` (imported by the integration), `package.json`; `node_modules`
 is linked, not copied) into `.cadence/runs/<wave>/tool/` and relaunches the orchestrate process from that copy (the
 parent process waits, relays the signals and exits with the same code or signal). Code, brief templates and agents
 therefore come from the snapshot: a wave can orchestrate cadence itself, and a session of the wave may edit
@@ -706,7 +706,19 @@ nothing below applies and the wave behaves as before; any other value is refused
      stacked). After the rebase the program lists the entries the lot's commits wrote under `[Unreleased]` that are neither at the starting point nor at
      the lot's tip (nor under a version the tip itself carries: an entry the lot published itself is final), drops them from the result (under `[Unreleased]` and under a version), and puts back an entry of the tip that is missing, in a commit of
      its own (`docs: CHANGELOG — une entrée finale par lot …`); an entry the repository's branch also carries is left alone. The union of an earlier replayed commit files the lot's entry at the end of its section; where the lot first put it (top of the section included) does not matter for the next replayed commit. The journal says
-     `<project>:<lot> CHANGELOG.md : une entrée finale par lot, les versions intermédiaires du lot écartées`. **A bare entry** (L383): an entry written under `## [Unreleased]` without a section on one side, against a section (`### Fixed`) the other side added, is not a free text: it is filed under that section (the entries of the repository's branch first), so the result has one title and one entry per lot. The section is the only one the two sides added to the base, or the only one they carry; with none, or several candidates, the conflict is left by hand. Anything else — an entry that
+     `<project>:<lot> CHANGELOG.md : une entrée finale par lot, les versions intermédiaires du lot écartées`. **A bare entry** (L383): an entry written under `## [Unreleased]` without a section on one side, against a section (`### Fixed`) the other side added, is not a free text: it is filed under that section (the entries of the repository's branch first), so the result has one title and one entry per lot. The section is the only one the two sides added to the base, or the only one they carry; with none, or several candidates, the conflict is left by hand.
+     **The ratchet's baseline** (L538): a lot that lowers `qualite-baseline.json` from an old `main` collides with the lots integrated since (the file is a
+     column of lines, so two edits on neighbouring keys conflict). When it is the **only** file in conflict, the program writes, for each key, the
+     repository's value plus the replayed commit's signed difference (the commit's parent version minus the commit's, so `main` minus the commit's
+     lowering), floored at 0, a key at 0 removed, the file sorted, indented by 2 spaces and ending with a newline (the format of `scripts/qualite.mjs`);
+     a key lowered by both sides is lowered twice, floored at 0. Beforehand the commit is checked with the gate's rule (`comparerMigration`, the commit's parent against
+     the commit; a file « exists » if it is in the parent of the replayed commit): a key of an existing file that goes up, or a total that goes up,
+     is not resolved. It is done **commit by commit**, so an intermediate commit that raises the baseline aborts the rebase even if a later one lowers it
+     again (the gate checks each state the same way). It is not resolved either when one of the three versions (parent, repository, commit) is missing
+     (the lot or the repository creates or deletes the file) or is not a flat key → number map. The journal says
+     `<project>:<lot> qualite-baseline.json : base recalculée sur main + baisses du lot (<n> commit(s))`. The ratchet is not bypassed: the checks of step 3 replay it at the
+     integrated tip, and a baseline too low for the measure hands the lot back with the red tests. Without a conflict on the baseline, git's result is kept.
+     Anything else — a CHANGELOG entry that
      was already there removed or reworded, free text under `[Unreleased]`, the rest of the
      file changed on both sides, another file in conflict with it — aborts the rebase and hands the lot back as above. The rebased commits differ, so
      steps 3 and 4 apply: tests replayed, and a short review since the patch-id changed;

package/docs/qualite.md

@@ -85,6 +85,11 @@ baseline (`--init` refuses as soon as `main` has a baseline: from then on `--ecr
 The refusal itself says so: when the start of the lot has no baseline, the list of measures that got worse ends with
 that command.
 
+**Integration of a lot that lowers the baseline** (L538): when `cadence orchestrate` rebases the lot on a `main` that changed the baseline too, the
+conflict on `qualite-baseline.json` is resolved by the program, commit by commit, as `main`'s baseline plus the lot's own difference (never below 0),
+after applying the rule above to the commit (`--migrer`'s: no existing file's key up, no total up). No manual rebase is needed; the details are in
+[orchestrate.md](orchestrate.md#one-worktree-per-lot-orchestrateworktrees-l279).
+
 The baseline is also the project's list of cleanups: each cleanup lot is measured by what it removes from it.
 
 ## Where it runs

package/docs/whats-new.md

@@ -4,6 +4,7 @@
 
 ## In two lines
 
+- **1.43.0**: the ratchet baseline is recomputed at integration (no more conflict hand-backs); `docs.sync` lets internal `refactor` commits through; `raf archive` keeps `raf list` order.
 - **1.42.1**: republishes 1.42.0, whose npm publication failed on two tests of the CI clone (no `main` branch, a draw-order probe that depended on timing); same features.
 - **1.42.0**: free plan identifiers (`plan.idPattern`, `raf add --id`, `raf estimate`); `--integrate` accepted while a wave runs; fair slot sharing between waves; the gate notices code that reads the plan.
 - **1.41.0**: richer plans (detailed states, extension fields); a light mockup step for visible lots that are not pages; `verify --sha` clears a red delivery; the quality ratchet watches its tools' config files.
@@ -72,6 +73,8 @@ Each is a paragraph in [docs/whats-new.md](whats-new.md) and a full section in [
 
 The long form of « In two lines » above (the README no longer carries a « What's new » section since L326: it links here). The full history, with the date of each version, is in [CHANGELOG.md](../CHANGELOG.md).
 
+**1.43.0**: fewer lots handed back for bookkeeping. When `qualite-baseline.json` is the only file in conflict at the integration of `cadence orchestrate`, the program recomputes it commit by commit (the repository's value plus the commit's own reductions, checked with the gate's rule), so a lot that lowers the baseline from an old `main` is integrated without a manual rebase and the ratchet stays green at the integrated tip; `scripts/qualite.mjs` now ships with the package (L538, `docs/orchestrate.md`, `docs/qualite.md`). `docs.sync` no longer reports « documentation en retard » for commits of type `refactor(L12): …` (cleanup or internal split with no change of behaviour); `refactor!:`, a `BREAKING CHANGE:` footer and every other type still count (L537, `docs/news.md`). With `plan.idPattern`, `raf archive` keeps an archived lot in its place in `raf list` through a `place:` key, and `raf todo` moves only the reopened lot to the end (L536).
+
 **1.42.1**: republishes 1.42.0, whose npm publication failed on two tests only (the ratchet test assumed a local `main` branch, the `--priority` probe read a timing-dependent order); no behaviour changes.
 
 **1.42.0**: plans can use your own identifiers. `plan.idPattern` accepts free ids (`AB-1.2`) in a writable plan, with `raf add --id`, flat sub-lots under a parent with `raf add --under`, commit references that follow the pattern, and `raf estimate <id> <days>` (L465). `cadence orchestrate --resume --wave <wave> --integrate <project:lot>` is now accepted while the wave still runs: a lot reviewed `conforme` is integrated without waiting for the end of a long `--continue` wave (L532, `docs/orchestrate.md`). Waves sharing the session slots take a freed slot in a common, fair order instead of letting one `--continue` wave starve a review (L531). `cadence verify --gate` replays the gate when code quotes the plan's path while `gate.readsPlan` is absent (L482, `docs/deliver.md`). `src/cli.ts` is split into one module per family of commands, with no behaviour change (L488, L485), and `raf estimate` rejects a non-number cleanly (L535).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylad/cadence",
-  "version": "1.42.1",
+  "version": "1.43.0",
   "description": "A small, repo-native working method: a versioned plan linked to your commits, a changelog with screenshots, session rituals and deliveries proven by their effect.",
   "license": "MIT",
   "author": "Sylvain Ladoire",
@@ -15,6 +15,8 @@
     "skills",
     "agents",
     "templates",
+    "scripts/qualite.mjs",
+    "scripts/qualite.d.mts",
     ".claude-plugin",
     "README.md",
     "NOTICE",

package/scripts/qualite.d.mts

@@ -0,0 +1,15 @@
+export const BASELINE: string;
+export type Mesure = Record<string, number>;
+export function lireEslint(json: { filePath: string; messages: { ruleId: string | null; message: string }[] }[], racine: string): Mesure;
+export function lireKnip(json: { files?: string[]; issues?: Record<string, unknown>[] }, racine: string): Mesure;
+/** `perimetres[nom]` : les fichiers (relatifs à `racine`) que l'outil de la directive `nom` analyse. */
+export function lireDirectives(racine: string, perimetres: Record<string, Iterable<string>>): Mesure;
+export function lireJscpd(rapport: { duplicates?: { firstFile: { name: string }; secondFile: { name: string }; lines?: number }[] }): Mesure;
+export function comparer(base: Mesure, courant: Mesure): { pires: { cle: string; avant: number; apres: number }[]; mieux: { cle: string; avant: number; apres: number }[] };
+export function serialiser(mesure: Mesure): string;
+export function lireBase(racine: string): Mesure;
+export function mesurer(racine: string): Mesure;
+export type Ref = { nom: string; base: Mesure | null; existe?: (chemin: string) => boolean; config?: (chemin: string) => string | null; fichiers?: () => string[] };
+export function comparerMigration(avant: Mesure, apres: Mesure, existe: (chemin: string) => boolean): { cle: string; avant: number; apres: number }[];
+export function lireRef(racine: string, ref: string): Ref;
+export function appliquer(racine: string, mode: 'verifier' | 'init' | 'ecrire' | 'migrer', mesure?: Mesure, ref?: Ref | null): { code: number; texte: string };