@sylad/cadence 1.40.0 → 1.42.1

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.40.0",
+      "version": "1.42.1",
       "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.40.0",
+  "version": "1.42.1",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/agents/spec-writer.md

@@ -14,6 +14,7 @@ Follow the brief you are given. The method:
    **Colours you add: semantic tokens, `on-*`, contrast.** Start from the charter's colour tokens and their text tokens (CSS variables). For every colour the screen adds, name a semantic token named by its role (`primary`, `success`, `warning`, `danger`, `surface`…) and its text token `on-<role>`; a colour added without its `on-*` token is a defect of the spec. The values come from a ramp drawn from the charter's brand colour (same hue, stepped lightness): the agent imports no external palette. A role already covered by a token of the charter keeps that token: reuse what exists, create no duplicate token, and only measure the existing pair. Write the measure in `contraste.md`, in the spec folder, committed with the sheet: `contraste.md` has two lists: the tokens created, and the existing pairs measured (an existing token appears only in the second), with one line per token / on-token pair: both values, the computed ratio (WCAG 2.2, relative luminance) and `ok` or `non`. Every pair is at least 4.5:1 (a pair at 4.49:1 is `non`, a pair at 4.5:1 is `ok`); fix a pair that falls short: change the step of the ramp, never the text size. A product with no CSS variable and no brand colour gets a mockup that follows its existing values: invent no ramp, measure the existing values in `contraste.md`, and write the absence of a coloured charter in the sheet. On a product that has a charter, never propose, draw or blame a generic style from a catalogue; with no charter, follow the existing values and say so, and choose no style.
 
 3. **Render and look.** Capture each state at **1440 px** and **390 px** wide with the browser tool (Playwright), named `maquette-<état>-<largeur>.png`, with the absolute capture-directory path your brief gives in front of the name (a bare name lands in the repository), and look at every capture before keeping it: a mockup you did not look at is not checked. Copy the kept captures into the spec folder.
+   **Light mockup** (the brief says so: a visible lot that is not a whole page): cover only the states the lot touches, and before drawing the target capture the CURRENT screen of each of those states at both widths, named `actuel-<état>-<largeur>.png`, in the same folder. If the current screen cannot be captured (the application does not start, the page is protected), say so under `nonVerifie` and base the mockup on the code: never invent a capture.
    Before keeping a state, check its sample data: compute the weekday of every date shown (`date -d`), never write it from memory.
 4. **Write the sheet** in the format of the template of the brief, and run `cadence spec check` on it until it passes. Every rule is `sourcee` (say where it comes from) or `hypothese` (say what would change if it were wrong, in `si_faux`). Never dress a guess as a source.
 5. **Costly choices are questions.** If a rule would fix a data model or storage, a public or shared API contract or an already published route, a destructive or irreversible action, or contradict an existing sourced rule, do not write it as a hypothesis: stop and ask, in the `questions` of the report. Wording, field order, the error state and spacing are written hypotheses.

package/agents/ux-reviewer.md

@@ -24,6 +24,8 @@ On top of the usability and accessibility checks, check the **consistency mockup
 - every state of `etats` has its section `#etat-<état>`; the `masque` of an empty-state rule really hides the fields it names;
 - the units, formats and wording the sheet declares are those shown.
 
+Light mockup (the brief says so): the sheet and the mockup cover only the states the lot touches. Sweep those states only, and compare the target of each one to the capture of the current screen `actuel-<état>-<largeur>.png` in the same folder (a free file the program does not check; when it is missing the spec writer said why under `nonVerifie`, judge the target against the code and the neighbouring pages). A defect of the screen that the lot does not touch is not a finding of this review.
+
 **Criteria added in mockup mode** — in this mode only (conformity mode and the review of an existing screen keep their text). Each one carries its named rule or the value to count; the checks of the method below (contrast, targets, keyboard, focus, alternatives, colour, reflow, data display) are already written there and are not repeated here.
 
 **Family: visual hierarchy**

package/dist/archive.js

@@ -29,13 +29,17 @@ export function selectArchivable(lots, before, blocked = () => null) {
 }
 /** Le numéro d'un identifiant (`L12` → 12) ; NaN pour un identifiant sans numéro. */
 const num = (id) => Number(/\d+$/.exec(id)?.[0] ?? NaN);
+/** La clé d'un lot archivé qui garde sa place : l'identifiant du lot qui le précédait dans le plan présenté (vide : il le commençait). */
+export const PLACE_KEY = 'place';
 /**
- * Les lots archivés remis à leur place parmi ceux du fichier actif : chacun juste avant le premier lot actif de numéro plus grand, à la fin
- * sinon, les archivés entre eux par numéro. L'ordre du fichier actif ne bouge jamais ; un plan que `raf add` tient dans l'ordre des numéros
- * (le cas ordinaire) se lit exactement comme avant l'archivage (L396).
+ * Les lots archivés remis à leur place parmi ceux du fichier actif. Un lot qui porte un rang (`places` : id → id du lot qui le précédait
+ * dans le plan présenté au moment de l'archivage, `raf archive` le pose sur tout lot archivé dès que `plan.idPattern` est déclaré : le nombre final d'un id ne dit alors rien de
+ * l'ordre) revient juste après ce lot, en tête quand le rang est vide, à la fin quand le lot du rang n'existe plus. Les autres vont juste
+ * avant le premier lot actif de numéro plus grand, à la fin sinon, entre eux par numéro. L'ordre du fichier actif ne bouge jamais ; un plan que
+ * `raf add` tient dans l'ordre des numéros (le cas ordinaire) se lit exactement comme avant l'archivage (L396).
  */
-export function mergeArchived(archived, active) {
-    const queue = [...archived].sort((a, b) => num(a.id) - num(b.id) || 0);
+export function mergeArchived(archived, active, places = new Map()) {
+    const queue = archived.filter((l) => !places.has(l.id)).sort((a, b) => num(a.id) - num(b.id) || 0);
     const out = [];
     for (const lot of active) {
         const n = num(lot.id);
@@ -43,7 +47,100 @@ export function mergeArchived(archived, active) {
             out.push(queue.shift());
         out.push(lot);
     }
-    return [...out, ...queue];
+    out.push(...queue);
+    return placeRanked(out, archived.filter((l) => places.has(l.id)), places);
+}
+/**
+ * Pose les lots à rang derrière leur prédécesseur, en un passage (L536 : sous `plan.idPattern` les archivés forment une seule chaîne de rangs,
+ * un plan de 685 lots ne peut pas payer k²·n à chaque lecture). Les lots d'un même rang se suivent dans l'ordre d'archivage (celui du fichier),
+ * chacun suivi des lots dont il est lui-même le rang ; le rang vide ouvre le plan. Un lot dont le prédécesseur ne viendra jamais (inconnu,
+ * cycle, lui-même) va à la fin du plan, dans l'ordre d'archivage.
+ */
+function placeRanked(out, ranked, places) {
+    const followers = new Map();
+    for (const l of ranked) {
+        const from = places.get(l.id);
+        followers.set(from, [...(followers.get(from) ?? []), l]);
+    }
+    const result = [];
+    const placed = new Set();
+    // Un lot posé entraîne ses suiveurs, puis les leurs : le parcours en profondeur (pile explicite, une chaîne peut être longue) rend
+    // exactement l'ordre que donnait la pose tour par tour.
+    const emit = (from) => {
+        const stack = [[...(followers.get(from) ?? [])].reverse()];
+        while (stack.length > 0) {
+            const next = stack[stack.length - 1].pop();
+            if (next === undefined)
+                stack.pop();
+            else if (!placed.has(next)) {
+                result.push(next);
+                placed.add(next);
+                stack.push([...(followers.get(next.id) ?? [])].reverse());
+            }
+        }
+    };
+    emit('');
+    // Un prédécesseur dont l'id est aussi dans le fichier actif (plan déjà en erreur) : les suiveurs vont derrière celui du fichier.
+    const seen = new Set();
+    for (const lot of out) {
+        result.push(lot);
+        if (!seen.has(lot.id))
+            emit(lot.id);
+        seen.add(lot.id);
+    }
+    return [...result, ...ranked.filter((l) => !placed.has(l))];
+}
+/**
+ * Les rangs à réécrire quand des lots archivés rouvrent (`back`, parmi `nodes`, les lots de toutes les archives) : un lot dont le `place:` nommait un lot
+ * rouvert est re-pointé sur le prédécesseur de celui-ci, de proche en proche, pour que seul le lot rouvert bouge dans le plan présenté (L536). Un lot rouvert
+ * sans rang (archivé avant `plan.idPattern`) prend pour prédécesseur celui du plan présenté (`order`, lu seulement alors). Rend les lots restés archivés dont le rang change.
+ */
+function repointPlaces(nodes, back, order) {
+    const places = new Map();
+    for (const n of nodes) {
+        const v = n.get(PLACE_KEY);
+        if (typeof v === 'string' || v === null)
+            places.set(n, v ?? '');
+    }
+    let presented;
+    for (const n of back.filter((b) => !places.has(b))) {
+        presented ??= order();
+        places.set(n, presented[presented.indexOf(String(n.get('id'))) - 1] ?? '');
+    }
+    const moved = new Map();
+    for (const n of back) {
+        const id = String(n.get('id'));
+        for (const s of nodes.filter((o) => places.get(o) === id)) {
+            places.set(s, places.get(n));
+            if (!back.includes(s))
+                moved.set(s, places.get(s));
+        }
+    }
+    return moved;
+}
+/**
+ * Les lots archivés qui ne sont plus clos (`raf todo` sur un lot done archivé) reviennent à la fin de la liste `active` du plan : seuls eux bougent,
+ * les lots restés archivés dont le `place:` les nommait sont re-pointés (`repointPlaces`, L536). Chaque archive touchée est marquée `dirty`.
+ */
+export function reopenArchived(archives, active, order) {
+    const nodes = archives.flatMap((a) => archiveLots(a.doc).items.filter(isMap).map((n) => ({ a, n: n })));
+    const back = nodes.filter(({ n }) => !['done', 'dropped'].includes(String(n.get('status'))));
+    if (back.length === 0)
+        return;
+    const moved = repointPlaces(nodes.map(({ n }) => n), back.map(({ n }) => n), order);
+    for (const { a, n } of nodes) {
+        if (back.some((b) => b.n === n)) {
+            const seq = archiveLots(a.doc);
+            seq.items = seq.items.filter((i) => i !== n);
+            n.delete(PLACE_KEY);
+            active.add(n);
+        }
+        else if (moved.has(n))
+            n.set(PLACE_KEY, moved.get(n));
+        else
+            continue;
+        a.dirty = true;
+    }
 }
 /** Année de rangement d'un lot : celle de sa fin, à défaut de sa création, à défaut d'aujourd'hui. */
 export function archiveYear(lot, today) {

package/dist/audit.js

@@ -6,7 +6,7 @@ import { changedFiles, fileAt, isAncestor, preloadChangedFiles, readCommits } fr
 import { citedRefs, linkCommits, scopeOf } from './link.js';
 import { PLAN_DEFAULT, PLAN_LEGACY, readDocsConfig, readNewsConfig, readOrchestrateConfig } from './config.js';
 import { ficheHypotheses } from './spec.js';
-import { docSyncGaps, filesOf, gapMessage } from './docsync.js';
+import { gapMessage, lotDocSyncGaps } from './docsync.js';
 import { loadEntries, newsIssues, PUBLIC_TITLE_DEFAULT, publicTitleTooLong, reusedNewsTitle } from './news.js';
 import { isRecurring } from './recurring.js';
 import { resourceIssues } from './resources.js';
@@ -233,7 +233,7 @@ function docSyncIssues(plan, root, byLot) {
         .lots()
         .filter((l) => !l.docsOk)
         .filter((l) => l.status === 'doing' || (l.status === 'done' && !!since && !!l.finished && l.finished >= since))
-        .flatMap((l) => docSyncGaps(sync, filesOf(root, workCommits(plan, root, byLot.get(l.id) ?? []))).map((g) => ({ message: gapMessage(l.id, g) })));
+        .flatMap((l) => lotDocSyncGaps(sync, root, workCommits(plan, root, byLot.get(l.id) ?? [])).map((g) => ({ message: gapMessage(l.id, g) })));
 }
 /** Commits qui portent du travail sur un lot : ni antérieurs à l'adoption du plan, ni acquittés (`raf ignore`), ni réduits au plan, ni une simple version. */
 function workCommits(plan, root, commits) {

package/dist/clean.js

@@ -219,7 +219,3 @@ export function scanStale(root, patterns, days, today) {
         unreadable: [...unreadable].sort(),
     };
 }
-/** Éléments périmés à proposer (voir `scanStale`), du plus vieux au plus récent. Ne supprime rien. */
-export function staleFiles(root, patterns, days, today) {
-    return scanStale(root, patterns, days, today).stale;
-}

package/dist/cli/context.js

@@ -0,0 +1,129 @@
+// Le contexte commun des commandes de raf et de cadence (L488, sorti de cli.ts) : les options, ce que dispatch construit, les assistants partagés.
+import { parseArgs } from 'node:util';
+import { dirname, join, relative, resolve } from 'node:path';
+import { defaultPlan, PLAN_DEFAULT, PLAN_LEGACY, readNewsConfig, readPlanConfig } from '../config.js';
+import { shellQuote } from '../deliver.js';
+import { gitRoot, isTracked } from '../git.js';
+import { publicTitleTooLong } from '../news.js';
+import { Plan, RafError } from '../plan.js';
+/** Les options de la ligne de commande, toutes commandes confondues : une option n'a de sens que pour certaines, chaque commande lit les siennes. */
+const OPTIONS = {
+    file: { type: 'string' },
+    project: { type: 'string' },
+    prefix: { type: 'string' },
+    'no-hook': { type: 'boolean' },
+    estimate: { type: 'string' },
+    quickwin: { type: 'boolean' },
+    visible: { type: 'boolean' },
+    screen: { type: 'string' },
+    spec: { type: 'boolean' },
+    local: { type: 'boolean' },
+    public: { type: 'string' },
+    every: { type: 'string' },
+    dir: { type: 'string' },
+    title: { type: 'string' },
+    after: { type: 'string' },
+    uses: { type: 'string' },
+    set: { type: 'string', multiple: true },
+    parent: { type: 'string' },
+    id: { type: 'string' },
+    under: { type: 'string' },
+    force: { type: 'boolean' },
+    back: { type: 'boolean' },
+    reason: { type: 'string' },
+    porteur: { type: 'string' },
+    status: { type: 'string' },
+    since: { type: 'string' },
+    before: { type: 'string' },
+    idle: { type: 'string' },
+    ttl: { type: 'string' },
+    session: { type: 'string' },
+    all: { type: 'boolean' },
+    depth: { type: 'string' },
+    output: { type: 'string', short: 'o' },
+    config: { type: 'string' },
+    'dry-run': { type: 'boolean' },
+    sha: { type: 'string' },
+    retry: { type: 'string' },
+    gate: { type: 'boolean' },
+    clear: { type: 'boolean' },
+    ignored: { type: 'boolean' },
+    notes: { type: 'boolean' },
+    json: { type: 'boolean' },
+    verbose: { type: 'boolean' },
+    classify: { type: 'boolean' },
+    model: { type: 'string' },
+    cache: { type: 'string' },
+    'cache-sous-causes': { type: 'string' },
+    sample: { type: 'string' },
+    sections: { type: 'string' },
+    slug: { type: 'string' },
+    quoi: { type: 'string' },
+    'sans-rendu': { type: 'boolean' },
+    out: { type: 'string' },
+    seuil: { type: 'string' },
+    'model-b': { type: 'string' },
+    double: { type: 'boolean' },
+    largeur: { type: 'string' },
+    until: { type: 'string' },
+    help: { type: 'boolean', short: 'h' },
+};
+export function parseCli(argv) {
+    return parseArgs({ args: argv, allowPositionals: true, options: OPTIONS });
+}
+/** Le contexte d'une commande qui lit le plan : ce que dispatch construit une fois, après les commandes qui n'en ont pas besoin. */
+export function buildCtx(base) {
+    const { command, rest, values, io, root } = base;
+    // cadence.yaml peut dire où est le plan et, s'il est tenu par un autre outil, comment le lire.
+    const configPath = resolve(io.cwd, values.config ?? join(root, 'cadence.yaml'));
+    // Installer les skills ou le hook ne lit pas le plan : un cadence.yaml fautif ne doit pas l'empêcher.
+    const installing = command === 'skills' || (command === 'hook' && rest[0] === 'install');
+    const planConfig = installing ? null : readPlanConfig(configPath, root);
+    // Le défaut (ni --file, ni RAF_FILE, ni plan:) : .cadence/raf.yaml, ou le docs/plan/raf.yaml hérité, dont le déplacement est proposé sur stderr (L246).
+    // --file et RAF_FILE se lisent depuis le dossier courant ; le plan: de cadence.yaml, depuis la racine du dépôt où est ce fichier.
+    const chosen = values.file ?? io.env.RAF_FILE ?? planConfig?.path;
+    const fallback = chosen === undefined ? defaultPlan(root) : null;
+    const planPath = resolve(io.cwd, values.file ?? io.env.RAF_FILE ?? (planConfig?.path !== undefined ? resolve(root, planConfig.path) : fallback.path));
+    if (fallback?.legacy && !installing)
+        (io.notice ?? io.err)(legacyPlanLine(root, fallback.legacy));
+    const loadPlan = () => Plan.load(planPath, { ...planConfig?.settings, config: configPath });
+    const newsDir = resolve(io.cwd, values.dir ?? join(root, 'docs/nouveautes'));
+    // Limite DÉCLARÉE (news.publicTitleMax) : sans clé, seul « raf check » avertit ; avec, la pose d'un titre public est refusée.
+    const refuseLongTitle = (text, hint = '') => {
+        const max = readNewsConfig(configPath).publicTitleMax;
+        const m = max === undefined ? null : publicTitleTooLong(text, max);
+        if (m)
+            throw new RafError(m + hint);
+    };
+    const need = (n, usage) => {
+        if (rest.length < n)
+            throw new RafError(`usage : raf ${usage}`);
+    };
+    return { ...base, configPath, planConfig, planPath, chosen, loadPlan, newsDir, refuseLongTitle, need };
+}
+/** `--verbose` (L453) : la ligne `id  état  titre entier` du lot touché par `done`, `ux`, `review`, `note`, `move`, `public` ; sans lui, rien de plus (une sous-tâche n'a pas de ligne). */
+export function touchedLot(plan, id, verbose, io) {
+    const lot = verbose ? plan.lots().find((l) => l.id === id) : undefined;
+    if (lot)
+        io.out(`${lot.id}  ${lot.status}  ${lot.title}`);
+}
+export function knownLot(plan, id, subtask) {
+    const lot = plan.lots().find((l) => l.id === id);
+    if (!lot)
+        throw new RafError(id.includes('/') ? `${subtask} : ${id}` : `lot inconnu : ${id}`);
+    return lot;
+}
+/** Le plan, relatif à la racine du dépôt git (comme les fichiers d'un commit), séparateurs `/`. */
+export function planFileIn(root, planPath) {
+    return relative(gitRoot(root) ?? root, planPath).split('\\').join('/');
+}
+/**
+ * La ligne stderr d'un docs/plan/raf.yaml hérité : le déplacement proposé (jamais fait), ou l'avertissement quand .cadence/raf.yaml existe aussi.
+ * La commande proposée commence par `cd <racine>` : elle s'exécute telle quelle depuis n'importe quel dossier (et non depuis la racine
+ * seulement) et, sous `session --all`, elle nomme le projet dont il s'agit.
+ */
+function legacyPlanLine(root, legacy) {
+    if (legacy === 'ignored')
+        return `raf: ${PLAN_LEGACY} est ignoré : ${PLAN_DEFAULT} existe aussi et fait foi (supprimer ou fusionner l'ancien)`;
+    return `raf: ${PLAN_LEGACY} est l'ancien emplacement du plan ; le déplacer : cd ${shellQuote(root)} && mkdir -p ${dirname(PLAN_DEFAULT)} && ${gitRoot(root) && isTracked(root, PLAN_LEGACY) ? 'git mv' : 'mv'} ${PLAN_LEGACY} ${PLAN_DEFAULT}`;
+}

package/dist/cli/deliver-commands.js

@@ -0,0 +1,114 @@
+// deliver, verify (et sa porte --gate) et local : la livraison du projet (L488, sorti de cli.ts).
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { defaultPlan, readDocsConfig, readOrchestrateConfig, readPlanConfig, readVerifyConfig } from '../config.js';
+import { deliver, parseDeliverConfig, realDeps } from '../deliver.js';
+import { defaultTarget, realCheckDeps, verifyCommand } from '../verify.js';
+import { verifyGate } from '../verify-gate.js';
+import { gitRoot, resolveCommit } from '../git.js';
+import { loadEntries } from '../news.js';
+import { RafError } from '../plan.js';
+import { waveHolding } from '../repo-busy.js';
+import { cadenceHome, waveLotsIn } from '../orchestrate/registry.js';
+import { blockingLots, LABEL } from '../orchestrate/table.js';
+import { localCommand, localLotOf } from '../local-task.js';
+import { sharedStateDir } from '../state.js';
+import { planFileIn } from './context.js';
+/**
+ * Ce qu'une livraison verte annonce et ouvre (lots livrés, article à rafraîchir, L144) : pour `cadence deliver` et pour la ligne verte
+ * que `cadence verify` inscrit (L435). Sans `public:`, un lot visible tire son titre de sa Nouveauté la plus récente.
+ */
+function deliveredEffects(p) {
+    const { root, configPath, newsDir, io } = p;
+    const publicTitle = (lot) => lot.public ?? (lot.visible ? loadEntries(newsDir).find((e) => e.lots.includes(lot.id))?.title : undefined);
+    const plan = existsSync(p.planPath) ? p.loadPlan() : null;
+    return { root, plan, today: p.today, articles: readDocsConfig(configPath).articles, publicTitle, planCommit: readPlanConfig(configPath, root)?.commit, waveId: p.waveId, out: io.out, err: io.err };
+}
+/** `verify --gate --sha rév [--project dossier]` (L348) : la porte du projet rejouée au sha ; `--project` est un sous-dossier du dossier courant qui a son propre dépôt. */
+async function verifyGateCommand(values, io) {
+    if (values.sha === undefined)
+        throw new RafError('verify --gate : --sha obligatoire (le sha à re-vérifier, jamais la tête mouvante d\'une vague)');
+    if (values.retry !== undefined)
+        throw new RafError('verify --gate : --retry ne va qu\'à verify seul (deliver.verify)');
+    const dir = values.project === undefined ? io.cwd : resolve(io.cwd, values.project);
+    if (values.project !== undefined && !existsSync(dir))
+        throw new RafError(`verify --gate : --project ${values.project} : dossier introuvable sous ${io.cwd}`);
+    const top = gitRoot(dir);
+    if (!top)
+        throw new RafError('verify --gate : à lancer dans un dépôt git (ou --project vers le dossier d\'un projet)');
+    if (values.project !== undefined && realpathSync(top) !== realpathSync(dir))
+        throw new RafError(`verify --gate : ${values.project} n'a pas son propre dépôt git (dépôt parent : ${top})`);
+    const configPath = resolve(io.cwd, values.config ?? join(top, 'cadence.yaml'));
+    const sha = resolveCommit(top, values.sha);
+    if (!sha)
+        throw new RafError(`verify --gate : --sha ${values.sha} : commit introuvable dans ${top}`);
+    // Le plan du projet (L444) : les commits qui ne changent que lui au-dessus du sha reprennent la porte du sha dessous. Illisible, il n'est pas cherché : la porte se rejoue.
+    let planFile;
+    try {
+        const configured = readPlanConfig(configPath, top)?.path;
+        planFile = planFileIn(top, configured !== undefined ? resolve(top, configured) : defaultPlan(top).path);
+    }
+    catch {
+        planFile = undefined;
+    }
+    return verifyGate({ repo: top, sha, config: readOrchestrateConfig(configPath), verify: readVerifyConfig(configPath), launchDirs: [io.cwd, top, dirname(top)], planFile, now: io.now, out: io.out });
+}
+/** cadence deliver : refusé pendant une vague sauf un sha livrable, puis la livraison du projet. */
+export function cmdDeliver(c) {
+    const { rest, values, io, today, root, configPath, planPath, loadPlan, newsDir } = c;
+    if (!gitRoot(io.cwd))
+        throw new RafError('deliver : à lancer dans un dépôt git');
+    const orchestrating = waveHolding(root, 'deliver');
+    if (orchestrating) {
+        const refusal = `deliver : orchestration en cours (vague ${orchestrating.wave}, pid ${orchestrating.pid})`;
+        if (values.sha === undefined)
+            throw new RafError(`${refusal} — livrer une fois les lots de ce dépôt finis (le verrou tombe dès que tous sont prêts ou rendus), ou un sha « livrable jusqu'à » de la vague (--sha)`);
+        // L277 : un sha dont tous les commits de la vague citent des lots prêts se livre au fil de l'eau ; l'état de la vague illisible ou un sha inconnu : refus.
+        const lots = waveLotsIn(cadenceHome(), orchestrating.pid, root);
+        const target = resolveCommit(root, values.sha);
+        if (lots === null)
+            throw new RafError(`${refusal} — état de la vague illisible : --sha ${values.sha} ne peut pas être vérifié`);
+        if (!target)
+            throw new RafError(`${refusal} — --sha ${values.sha} : commit introuvable`);
+        const { blocking, unreadable } = blockingLots(lots, root, target);
+        if (blocking.length > 0) {
+            throw new RafError(`${refusal} — ${target.slice(0, 7)} contient des commits de lots pas prêts : ${blocking.map((l) => `${l.project}:${l.lot} (${LABEL[l.status]})`).join(', ')} ; livrer un sha antérieur (« livrable jusqu'à » du tableau de la vague) ou attendre leur fin`);
+        }
+        if (unreadable.length > 0) {
+            throw new RafError(`${refusal} — commits illisibles (plan du projet ou dépôt) des lots pas prêts ${unreadable.map((l) => `${l.project}:${l.lot} (${LABEL[l.status]})`).join(', ')} : --sha ${values.sha} ne peut pas être vérifié ; rétablir le plan ou attendre la fin de ces lots`);
+        }
+    }
+    if (!existsSync(configPath))
+        throw new RafError(`pas de configuration de livraison : ${configPath} (voir « cadence.yaml » dans docs/deliver.md du paquet @sylad/cadence)`);
+    const config = parseDeliverConfig(readFileSync(configPath, 'utf8'), configPath);
+    const effects = deliveredEffects({ root, configPath, planPath, loadPlan, newsDir, today, waveId: orchestrating?.wave, io });
+    return deliver({ ...effects, state: sharedStateDir(root), config, dryRun: !!values['dry-run'], sha: values.sha, duringWave: !!orchestrating, args: rest }, realDeps(root));
+}
+/** cadence verify [--gate] : rejoue deliver.verify, ou la porte du projet. */
+export function cmdVerify(c) {
+    const { values, io, today, root, configPath, planPath, loadPlan, newsDir } = c;
+    if (values.gate)
+        return verifyGateCommand(values, io);
+    if (!gitRoot(io.cwd))
+        throw new RafError('verify : à lancer dans un dépôt git');
+    if (!existsSync(configPath))
+        throw new RafError(`pas de configuration : ${configPath} (voir « cadence.yaml » dans docs/deliver.md du paquet @sylad/cadence)`);
+    const retry = values.retry === undefined ? 0 : Number(values.retry);
+    if (!Number.isFinite(retry) || retry < 0)
+        throw new RafError(`--retry invalide : ${values.retry} (secondes, 0 ou plus)`);
+    const config = parseDeliverConfig(readFileSync(configPath, 'utf8'), configPath);
+    const target = values.sha ? { sha: resolveCommit(root, values.sha) ?? '', note: null } : defaultTarget(root, config);
+    if (values.sha && !target.sha)
+        throw new RafError(`--sha ${values.sha} : commit introuvable`);
+    // Une ligne verte écrite par verify (L435) est une livraison : mêmes effets que deliver (lots annoncés, article à rafraîchir, L144).
+    // verify lit le verrou sans refuser : une tâche locale du lead (L519) n'empêche pas de rejouer les vérifications, et n'est pas une vague à citer.
+    const holding = waveHolding(root);
+    const waveId = holding && !localLotOf(holding.wave) ? holding.wave : undefined;
+    const effects = () => deliveredEffects({ root, configPath, planPath, loadPlan, newsDir, today, waveId, io });
+    return verifyCommand({ config, sha: target.sha, note: target.note, retry, out: io.out, journal: { dir: sharedStateDir(root), day: today, effects } }, realCheckDeps(root));
+}
+/** cadence local start|done|abort : la tâche locale du lead. */
+export function cmdLocal(c) {
+    const { rest, values, io, today, root, loadPlan } = c;
+    return localCommand(rest, values.ttl, { repo: gitRoot(root) ?? root, loadPlan, today, now: io.now, gate: (sha) => verifyGateCommand({ sha }, io), out: io.out, err: io.err });
+}