@sylad/cadence 1.7.0 → 1.9.0

package/dist/cli.js

@@ -2,28 +2,33 @@ import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from
 import { execFileSync } from 'node:child_process';
 import { basename, dirname, join, posix, relative, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
-import { readDocsConfig, readHookConfig, readNewsConfig, readOrchestrateConfig, readPlanConfig, readSessionConfig } from './config.js';
+import { defaultPlan, PLAN_DEFAULT, PLAN_LEGACY, readDocsConfig, readHookConfig, readNewsConfig, readOrchestrateConfig, readPerfConfig, readPlanConfig, readSessionConfig } from './config.js';
 import { repoSections, repoShas, resolveLotRepos } from './repos.js';
 import { audit, exemptPlanOnly, gateProgress, gateText, gateWaiting, hypothesesOf, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
 import { short } from './check.js';
 import { isDay, toDay } from './dates.js';
-import { deliver, parseDeliverConfig, realDeps } from './deliver.js';
+import { deliver, parseDeliverConfig, realDeps, shellQuote } from './deliver.js';
 import { defaultTarget, effectLines, realCheckDeps, verifyCommand } from './verify.js';
 import { ganttData, renderGantt } from './gantt.js';
-import { gitRoot, readCommits, matchesHead, resolveCommit, stage, stagedFiles, syncIndexWithHead } from './git.js';
+import { gitRoot, isTracked, readCommits, matchesHead, resolveCommit, stage, stagedFiles, syncIndexWithHead } from './git.js';
 import { installHook, pendingCommitMessage, REFUSED } from './hook.js';
 import { citedRefs, linkCommits } from './link.js';
 import { buildNews, loadEntries, newEntry, newsData, newsIssues, publicTitleTooLong, stampEntries } from './news.js';
-import { Plan, RafError, SCREENS, STATUSES } from './plan.js';
+import { invalidResource, Plan, RafError, SCREENS, STATUSES } from './plan.js';
 import { dueLine, isRecurring, recurringByDue } from './recurring.js';
 import { schedule } from './schedule.js';
 import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.js';
-import { findProjects, leadTour, readLeadUx, tourLine } from './lead.js';
-import { configuredCap, liveLines, orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
+import { findProjects, leadTour, readLeadUx, tourFreeLine, tourLine, tourWorktreeLines } from './lead.js';
+import { configuredCap, expiredHoldLines, liveLines, orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
+import { addHold, releaseHold } from './orchestrate/registry.js';
 import { activeLock, REPO_LOCK } from './orchestrate/lock.js';
-import { cadenceHome, openLotsIn } from './orchestrate/registry.js';
-import { classifyAll, measure, ollamaClassifier, readCache, readRuns, renderReport, sampleKeys, serializeCache } from './corrections.js';
+import { cadenceHome, liveWaves, openLotsIn, openWavesIn, waveLotsIn } from './orchestrate/registry.js';
+import { blockingLots, LABEL } from './orchestrate/table.js';
+import { classifyAll, measure, ollamaClassifier, readCache, readJournals, readRuns, renderReport, sampleKeys, serializeCache } from './corrections.js';
+import { computePerf, perfHeader, perfWindows, readPlans, readProjectDeliveries, readProjectFailedEntries, renderPerf } from './perf.js';
 import { findAcceptation, parseAcceptation, resealAcceptation } from './orchestrate/accept.js';
+import { refCommand } from './ref/command.js';
+import { applyMigration, describeMigration, planMigration, unhandledError } from './migrate.js';
 import { checkFiche, deriveQa, readFiche, summary } from './spec.js';
 import { readHudContext } from './hud-context.js';
 import { sessionClose, sessionStart } from './session.js';
@@ -31,13 +36,16 @@ import { clearNext, readNext, sharedStateDir, stateDir, writeNext } from './stat
 const HELP = `raf — plan « reste à faire » versionné dans le dépôt, relié aux commits
 
   raf init [--project nom] [--prefix L] [--no-hook]
-  raf add "titre" [--estimate j] [--quickwin] [--visible [--screen page|component|journey]] [--spec] [--public "titre public"] [--every jours] [--after L2,L4] [--parent L3]
+  raf add "titre" [--estimate j] [--quickwin] [--visible [--screen page|component|journey]] [--spec] [--public "titre public"] [--every jours] [--after L2,L4] [--uses banc,passerelle] [--parent L3]
   raf public <id> "titre public" | --clear   titre du lot dans le langage du public (pages Nouveautés et Plan)
   raf screen <id> page|component|journey|none   pose, remplace ou retire screen: d'un lot visible existant (seule la valeur page adopte l'étape spec d'orchestrate)
+  raf visible <id> on|off   pose ou retire visible: d'un lot existant (changement visible : entrée Nouveautés et étape UX d'orchestrate) ; off est refusé tant que le lot a un screen:
   raf spec <id> on|off   pose ou retire spec: d'un lot existant (le lot change un comportement : étape spec back d'orchestrate)
+  raf uses <lot> [<ressource>…]   remplace les ressources partagées du lot (uses:, déclarées par resources: dans le cadence.yaml du dossier parent ; raf check refuse un nom non déclaré) ; sans nom, retire la clé
   raf start <id>        raf done <id> [--force]        raf drop <id> [--reason texte]
   raf todo <id> [--reason texte]   remet en attente un lot démarré sans commit de travail (doing → todo, started retiré, note datée) ; refusé s'il a des commits
   raf note <id> "texte"
+  raf title <id> "nouveau titre"   remplace le titre d'un lot, de tout statut (done compris), et note l'ancien dans une note datée
   raf did <id> ["texte"]   un lot récurrent (--every) a été refait : le « dû depuis N j » repart de aujourd'hui
   raf ux enable         revue UX obligatoire avant « done » pour les lots --visible
   raf ux <id> "verdict" enregistre la revue d'ergonomie du lot (agent ux-reviewer)
@@ -49,11 +57,20 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf list [--status todo|doing|done|dropped]
   raf check [--since date] [--idle 7]   (défaut : date « since » du plan) code 1 s'il y a des écarts
   raf ignore <sha> | "<sujet exact>" [--reason texte]   acquitte un commit sans lot (ou citant un id inconnu) sans réécrire l'historique ; raf check --ignored les liste
-  raf gantt [-o docs/plan/gantt.html]
+  raf gantt [-o .cadence/gantt.html]
+  raf migrate [--dry-run]   déplace docs/plan/raf.yaml vers .cadence/raf.yaml (git mv) et réécrit les lecteurs du chemin dans le dépôt ; --dry-run les liste sans rien toucher ; refus tant qu'un lecteur n'est pas traité (migrate.keep de cadence.yaml pour ceux qui ne lisent pas le plan) ; rejouable
   raf hook install      (pre-commit et post-commit ; cadence.yaml hook.autostart: warn|refuse|start)
-  cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--dry-run] [--wave nom] [--continue [--until HH:MM] [--priority a,b]]   une session claude neuve par étape ; --status [vague] [--watch [--interval s]] ; --resume [vague] [--budget 1M] [--budget projet:lot=+300k] [--answer projet:lot "réponse"] [--drop projet:lot] ; --drop projet:lot [--wave vague] ; --stop-after-current [--wave vague] ; --waits [--since AAAA-MM-JJ]
-  cadence lead tour [dossier] [--idle 3] [--depth n] [--json]   le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan, ou la ligne du dossier seul s'il est lui-même un projet (en cours, dérive, notes de clôture, prochain lot prêt, dépôt)
+  cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--goal "…"] [--dry-run] [--wave nom] [--continue [--until HH:MM] [--priority a,b]]   une session claude neuve par étape ; --status [vague] [--watch [--interval s]] ; --resume [vague] [--budget 1M] [--budget projet:lot=+300k] [--answer projet:lot "réponse"] [--drop projet:lot] ; --drop projet:lot [--wave vague] ; --stop-after-current [--wave vague] ; --waits [--since AAAA-MM-JJ]
+                        mode worktree par lot (orchestrate.worktrees: true) : EXPÉRIMENTAL, NON ACTIVABLE (refusé, code 2) tant que L299, L300 et L301 ne sont pas faits, sauf CADENCE_EXPERIMENTAL_WORKTREES=1 (tests) ; ses options : --resume <vague> --integrate projet:lot (rejoue un lot rendu à l'intégration) · --resume <vague> --replay projet:lot (idem, et après une écriture de plan refusée) · --remove-worktree projet:lot [--abandon-commits] (retire le worktree et la branche conservés) ; la liste des worktrees conservés : orchestrate --status et lead tour
+  cadence lead tour [dossier] [--idle 3] [--depth n] [--json]   le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan, ou la ligne du dossier seul s'il est lui-même un projet (en cours, dérive, notes de clôture, prochain lot prêt, dépôt), précédées de l'en-tête perf : une ligne par ⚠ de cadence perf, rien si tout est stable
+  cadence lead hold <étiquette> [--ttl minutes] | lead release <étiquette>   déclare (60 min par défaut), puis rend, une session lancée à la main par le lead : elle est soustraite des créneaux libres de orchestrate --status et de lead tour ; au TTL échu, les deux la signalent en ⚠ jusqu'au release
   cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until date] [--since date] [--json]   mesure des passes de correction des journaux dossier/.cadence/runs : lots à ≥1 et ≥2 corrections, par projet, visibles ou non, passes par cause (classées par Ollama avec --classify, hors quota)
+  cadence perf [dossier] [--since date] [--json]   tableau de bord du workflow, sans modèle : deux fenêtres (7 derniers jours contre les 7 précédents) lues dans dossier/.cadence/runs et les plans, chaque vitesse à côté de sa qualité, ⚠ au-delà de 25 % de dégradation ; tokens par lot selon l'estimate, part de la revue, délais création → done → livraison, durée de mur par étape, coût en euros par lot livré (grille cadence.yaml perf.prices) ; --since est un jour qui tronque les fenêtres
+  cadence ref add <document.pdf> [--sections 3-5,9] [--slug nom]   enregistre un document de référence hors du dépôt (references.dir de cadence.yaml, sinon $XDG_DATA_HOME/cadence/references) : pages rendues à 200 dpi, texte positionné, images incluses, index des figures et des passages qui les citent ; exige poppler, ImageMagick et tesseract (outil absent nommé avec sa commande, code 2)
+  cadence ref measure <slug> <page> <page | x,y | x,y,l,h> [--quoi couleurs|contraste|boites|texte] [--largeur 1440] [--json]   mesure une zone d'une page rendue (pixels de la page) : couleurs (point, moyenne, dominantes), contraste WCAG 2.2, boîtes, mots OCR tesseract et taille de police estimée ; valeurs ramenées à 1440 px de large, tolérance déclarée
+  cadence ref check <inventaire.json | lecture.json>   valide un inventaire ou une lecture (schéma version 1, modèle templates/inventaire.json) : une ligne « ✗ chemin : raison » par écart puis « N écart(s) » sur la sortie standard (code 1), le résumé par type sinon (code 0) ; fichier absent, vide ou illisible : code 2 ; n'appelle aucun outil système
+  cadence ref eval <attendu.json | dossier> <lecture.json | dossier> [--json]   note une lecture contre l'inventaire attendu (vérité connue) : rappel et précision par type, faux lu (éléments sûrs et faux), pièges trouvés, tokens par page (usage.tokens de la lecture) ; lecture d'un autre document refusée (code 2) ; sur dossiers, un cas par sous-dossier (attendu.json / lecture.json)
+  cadence ref corpus <dossier> [--sans-rendu]   écrit le corpus synthétique à vérité connue (7 pièges : texte ambigu levé par une figure, figure qui contredit, table en image, gabarit BUFR, contrôle translucide, page Proposal, scan bruité) : par cas document.html et attendu.json, puis document.pdf et page-<n>.png (1700×2200) rendus par Playwright (CADENCE_PLAYWRIGHT = dossier du paquet) ; dossier existant ou Playwright introuvable : code 2
   cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
   raf news new <lot…> [--title t] | list | check | stamp | build [-o dossier]   (aussi « cadence news … »)
 
@@ -65,7 +82,7 @@ Un commit qui ne touche que le plan, la clé plan: de cadence.yaml (deliver/sess
 publié par exemple, ainsi que le fichier d'attendus QA : docs/qa/expectations.md ou qa.expectations) n'a pas à en citer, et ne compte pas pour les lots qu'il cite ; le sujet n'y change rien.
 Un lot --visible attend une entrée Nouveautés (docs/nouveautes/, --dir) avec capture ; raf check le vérifie.
 Un texte qui commence par « - » se passe après « -- » : raf note L1 -- "-5 %".
-Le plan est docs/plan/raf.yaml, ou celui que nomme « plan: » dans cadence.yaml ; un plan tenu par un
+Le plan est .cadence/raf.yaml (versionné, jamais publié avec docs/ ; un docs/plan/raf.yaml hérité reste lu, raf propose le git mv (mv si git ne le suit pas), avec cd <racine> pour qu'il s'exécute de n'importe quel dossier), ou celui que nomme « plan: » dans cadence.yaml ; un plan tenu par un
 autre outil se lit sans migration (correspondance des champs, voir docs/raf.md du paquet @sylad/cadence) et reste en lecture seule.
 Options communes : --file chemin (ou RAF_FILE), RAF_TODAY=AAAA-MM-JJ pour figer la date.`;
 /** Ajoute `line` au .gitignore de `root` s'il n'y est pas déjà (avec ou sans `/` initial ou final). Rend vrai si écrit. */
@@ -78,6 +95,16 @@ export function ensureGitignore(root, line) {
     writeFileSync(file, `${text}${text === '' || text.endsWith('\n') ? '' : '\n'}${line}\n`);
     return true;
 }
+/**
+ * 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}`;
+}
 export function run(argv, io) {
     try {
         // orchestrate a ses propres options (--status et --resume prennent une valeur facultative, --answer en prend deux).
@@ -121,6 +148,7 @@ function dispatch(argv, io) {
             dir: { type: 'string' },
             title: { type: 'string' },
             after: { type: 'string' },
+            uses: { type: 'string' },
             parent: { type: 'string' },
             force: { type: 'boolean' },
             reason: { type: 'string' },
@@ -128,6 +156,7 @@ function dispatch(argv, io) {
             status: { type: 'string' },
             since: { type: 'string' },
             idle: { type: 'string' },
+            ttl: { type: 'string' },
             session: { type: 'string' },
             all: { type: 'boolean' },
             depth: { type: 'string' },
@@ -144,6 +173,11 @@ function dispatch(argv, io) {
             model: { type: 'string' },
             cache: { type: 'string' },
             sample: { type: 'string' },
+            sections: { type: 'string' },
+            slug: { type: 'string' },
+            quoi: { type: 'string' },
+            'sans-rendu': { type: 'boolean' },
+            largeur: { type: 'string' },
             until: { type: 'string' },
             help: { type: 'boolean', short: 'h' },
         },
@@ -161,8 +195,12 @@ function dispatch(argv, io) {
     const root = gitRoot(io.cwd) ?? io.cwd;
     // Le tour parcourt les sous-dossiers (ou, sans sous-projet, prend le dossier lui-même s'il est un projet) : il ne lit pas le plan du dossier courant.
     if (command === 'lead') {
+        if (rest[0] === 'hold' || rest[0] === 'release')
+            return leadHold(rest, values.ttl, io);
+        if (values.ttl !== undefined)
+            throw new RafError('--ttl ne va qu\'avec lead hold');
         if (rest[0] !== 'tour' || rest.length > 2)
-            throw new RafError('usage : cadence lead tour [dossier] [--idle 3] [--depth n] [--json]');
+            throw new RafError('usage : cadence lead tour [dossier] [--idle 3] [--depth n] [--json] | lead hold <étiquette> [--ttl minutes] | lead release <étiquette>');
         const idle = values.idle === undefined ? undefined : Number(values.idle);
         if (idle !== undefined && !(Number.isInteger(idle) && idle >= 0))
             throw new RafError(`--idle invalide : ${values.idle}`);
@@ -176,14 +214,32 @@ function dispatch(argv, io) {
         if (values.json)
             io.out(JSON.stringify(rows, null, 2));
         else if (rows.length === 0)
-            io.out(`aucun projet sous ${parent} (docs/plan/raf.yaml ou cadence.yaml avec plan:)`);
+            io.out(`aucun projet sous ${parent} (.cadence/raf.yaml, docs/plan/raf.yaml ou cadence.yaml avec plan:)`);
         else {
+            // L'en-tête perf (L227) : un ⚠ par ligne avant les projets ; un dossier que perf ne lit pas n'en donne pas, et ses avertissements ne sont pas repris.
+            try {
+                for (const l of perfHeader(readPerf(parent, today, undefined, () => { })))
+                    io.out(l);
+            }
+            catch {
+                // pas de .cadence/runs, grille de prix mal formée, journaux ou plans illisibles : le tour ne change pas
+            }
             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()))
+                io.out(l);
             // les créneaux libres viennent du registre, le lead les lit au lieu de les calculer (L141)
-            const [slots] = liveLines(configuredCap(io.env));
+            const [slots] = liveLines(configuredCap(io.env), io.now());
             if (slots)
                 io.out(slots);
+            // en face des créneaux libres, les lots prêts dont aucune ressource n'est prise (L252) ; sans vague en cours ni session tenue par le lead (L255), pas de créneau à remplir : seul --json les donne
+            const free = slots ? tourFreeLine(rows) : null;
+            if (free)
+                io.out(free);
+            // une session du lead dont le TTL est échu (L278) : rien ne l'arrête, le tour la signale (hors --json, comme les créneaux)
+            for (const l of expiredHoldLines(io.now()))
+                io.out(l);
             // le réglage lead.ux du cadence.yaml du dossier (L197) : le lead lit ici qui pose le verdict UX, au lieu d'ouvrir le fichier
             try {
                 if (readLeadUx(parent) === 'lead')
@@ -199,6 +255,25 @@ function dispatch(argv, io) {
     }
     if (command === 'corrections')
         return corrections(rest, values, io);
+    if (command === 'perf')
+        return perf(rest, values, today, io);
+    if (command === 'ref')
+        return refCommand(rest, values, root, io);
+    // Déplacer le plan ne lit pas le plan : pas d'avertissement « ancien emplacement » (L284).
+    if (command === 'migrate') {
+        if (rest.length > 0)
+            throw new RafError('usage : raf migrate [--dry-run]');
+        const migration = planMigration(root);
+        // --dry-run décrit ce qui serait fait avant de refuser ; sans lui, un refus n'annonce rien de fait.
+        if (values['dry-run'] || migration.unhandled.length === 0)
+            for (const l of describeMigration(migration, !!values['dry-run']))
+                io.out(l);
+        if (migration.unhandled.length > 0)
+            throw unhandledError(migration);
+        if (!values['dry-run'])
+            applyMigration(root, migration);
+        return 0;
+    }
     // `spec` est aussi un verbe de raf (raf spec <lot> on|off, L186) : seuls check et qa vont à la fiche.
     if (command === 'spec' && (rest[0] === 'check' || rest[0] === 'qa'))
         return spec(rest, io);
@@ -211,7 +286,13 @@ function dispatch(argv, io) {
     // 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);
-    const planPath = resolve(io.cwd, values.file ?? io.env.RAF_FILE ?? resolve(root, planConfig?.path ?? 'docs/plan/raf.yaml'));
+    // 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.
@@ -235,6 +316,10 @@ function dispatch(argv, io) {
                 throw new RafError(`plan en lecture seule : ${configPath} décrit un plan tenu par un autre outil`);
             const plan = Plan.create(planPath, values.project ?? basename(root), values.prefix ?? 'L', today);
             io.out(`plan créé : ${plan.path}`);
+            if (chosen === undefined) {
+                mkdirSync(join(root, '.cadence/notes'), { recursive: true });
+                writeFileSync(join(root, '.cadence/notes/.gitkeep'), '');
+            }
             if (ensureGitignore(root, '.playwright-mcp/'))
                 io.out('.gitignore : .playwright-mcp/');
             if (!values['no-hook'] && gitRoot(io.cwd))
@@ -254,6 +339,8 @@ function dispatch(argv, io) {
                     throw new RafError('--public se pose sur un lot, pas sur une sous-tâche');
                 if (values.every !== undefined)
                     throw new RafError('--every se pose sur un lot, pas sur une sous-tâche');
+                if (values.uses !== undefined)
+                    throw new RafError(`uses se pose sur un lot, pas sur une sous-tâche : ${values.parent}`);
                 id = plan.addTask(values.parent, rest.join(' '));
             }
             else {
@@ -266,7 +353,10 @@ function dispatch(argv, io) {
                     throw new RafError(`périodicité invalide : ${values.every} (un nombre entier de jours)`);
                 if (values.public !== undefined)
                     refuseLongTitle(values.public);
-                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, screen: values.screen, spec: values.spec, public: values.public, every, after });
+                const uses = values.uses?.split(',').map((n) => n.trim()).filter(Boolean);
+                if (uses?.length === 0)
+                    throw new RafError(invalidResource(''));
+                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, screen: values.screen, spec: values.spec, public: values.public, every, after, uses });
             }
             plan.save();
             io.out(id);
@@ -324,6 +414,20 @@ function dispatch(argv, io) {
             io.out(`${rest[0]} refait le ${today}`);
             return 0;
         }
+        case 'title': {
+            need(2, 'title <id> "nouveau titre"');
+            const plan = loadPlan();
+            plan.setTitle(rest[0], rest.slice(1).join(' '), today);
+            plan.save();
+            return 0;
+        }
+        case 'uses': {
+            need(1, 'uses <lot> [<ressource>…]');
+            const plan = loadPlan();
+            plan.setUses(rest[0], rest.slice(1));
+            plan.save();
+            return 0;
+        }
         case 'public': {
             need(values.clear ? 1 : 2, 'public <id> "titre public" | public <id> --clear');
             if (values.clear && rest.length > 1)
@@ -346,6 +450,14 @@ function dispatch(argv, io) {
             plan.save();
             return 0;
         }
+        case 'visible': {
+            if (rest.length !== 2 || (rest[1] !== 'on' && rest[1] !== 'off'))
+                throw new RafError('usage : raf visible <id> on|off');
+            const plan = loadPlan();
+            plan.setVisible(rest[0], rest[1] === 'on');
+            plan.save();
+            return 0;
+        }
         case 'spec': {
             if (reseal)
                 return specReseal(rest.slice(1), values.reason, values.porteur, { root, loadPlan, configPath, today }, io);
@@ -385,6 +497,8 @@ function dispatch(argv, io) {
                 return 0;
             }
             io.out(`${lot.id}  ${lot.status}  ${lot.title}`);
+            if (lot.goal)
+                io.out(`goal : ${lot.goal}`);
             const dates = [['créé', lot.created], ['démarré', lot.started], [lot.status === 'dropped' ? 'abandonné' : 'terminé', lot.finished]].filter(([, d]) => d);
             if (dates.length)
                 io.out(dates.map(([k, d]) => `${k} : ${d}`).join('  '));
@@ -396,6 +510,8 @@ function dispatch(argv, io) {
                 io.out(`screen : ${lot.screen}`);
             if (lot.spec)
                 io.out('spec : true');
+            if (lot.uses)
+                io.out(`uses : ${lot.uses.join(', ')}`);
             const gate = gateProgress(plan.lots(), lot);
             if (lot.gate && gate)
                 io.out(lot.gate.invalid ? `gate : ${gateText(gate)}` : `gate : ${gate.n} lots ${gate.label} faits`);
@@ -426,16 +542,18 @@ function dispatch(argv, io) {
             return now(loadPlan(), root, newsDir, today, io);
         case 'ignore': {
             need(1, 'ignore <sha> | "<sujet exact>" [--reason texte]');
+            if (rest.length > 1)
+                throw new RafError('un seul commit attendu ; la raison se passe par --reason "texte"');
             const plan = loadPlan();
-            const arg = rest.join(' ');
+            const arg = rest[0];
             const commits = planCommits(plan, root);
             // Un sujet exact l'emporte sur un nom de ref homonyme (`other` à la fois sujet et branche).
-            const sha = rest.length === 1 && !commits.some((c) => c.subject === arg) ? resolveCommit(root, rest[0]) : null;
-            const found = rest.length === 1 && sha ? commits.find((c) => c.sha === sha) : commits.find((c) => c.subject === arg);
+            const sha = commits.some((c) => c.subject === arg) ? null : resolveCommit(root, arg);
+            const found = sha ? commits.find((c) => c.sha === sha) : commits.find((c) => c.subject === arg);
             if (!found)
                 throw new RafError(`aucun commit ne correspond à « ${arg} » (sha ou sujet exact)`);
             // Un sha est exact ; un sujet vaut pour tous les commits qui le portent.
-            const bySha = rest.length === 1 && sha !== null;
+            const bySha = sha !== null;
             plan.acknowledge({ ...(bySha ? { sha: found.sha, subject: found.subject } : { subject: found.subject }), date: today, ...(values.reason ? { reason: values.reason } : {}) });
             plan.save();
             io.out(`${bySha ? short(found) : found.subject} acquitté`);
@@ -509,8 +627,25 @@ function dispatch(argv, io) {
             if (!gitRoot(io.cwd))
                 throw new RafError('deliver : à lancer dans un dépôt git');
             const orchestrating = waveHolding(root);
-            if (orchestrating)
-                throw new RafError(`deliver : orchestration en cours (vague ${orchestrating.wave}, pid ${orchestrating.pid}) — livrer une fois les lots de ce dépôt finis (le verrou tombe dès que tous sont prêts ou rendus)`);
+            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);
@@ -518,7 +653,7 @@ function dispatch(argv, io) {
             const articles = readDocsConfig(configPath).articles;
             // Sans public: d'un lot visible, le site reprend le titre de sa Nouveauté la plus récente.
             const publicTitle = (lot) => lot.public ?? (lot.visible ? loadEntries(newsDir).find((e) => e.lots.includes(lot.id))?.title : undefined);
-            const ctx = { root, state: sharedStateDir(root), plan, config, today, dryRun: !!values['dry-run'], sha: values.sha, args: rest, articles, publicTitle, out: io.out, err: io.err };
+            const ctx = { root, state: sharedStateDir(root), plan, config, today, dryRun: !!values['dry-run'], sha: values.sha, duringWave: !!orchestrating, args: rest, articles, publicTitle, out: io.out, err: io.err };
             return deliver(ctx, realDeps(root));
         }
         case 'verify': {
@@ -830,15 +965,65 @@ function waveHolding(root) {
  * acceptation.json, commite test + acceptation (le nouveau commit rouge), et note la raison au lot. Le verrou garde tout le reste.
  */
 const git = (cwd, args) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+/** Chemin à coller dans un shell : entre apostrophes dès qu'il contient autre chose que des caractères sûrs. */
+const shellPath = (p) => (/^[\w@%+=:,./-]+$/.test(p) ? p : `'${p.replace(/'/g, "'\\''")}'`);
+/** Le refus de `spec reseal` devant des vagues non terminées (L238) : chaque vague (vivante ou arrêtée), son dossier de lancement, ses lots, et pour chaque vague arrêtée UNE commande à lancer telle quelle (un `--drop` par lot ouvert du dépôt, y compris ceux en file qui ne sont pas en cours au plan : `--resume` relance toute la vague avec les lots non retirés, et un lot en file reprendrait le verrou, L239). */
+function openWavesRefusal(open) {
+    const lines = open.map((w) => {
+        const where = [w.live ? 'vivante' : 'arrêtée', ...(w.live && w.pid !== undefined ? [`pid ${w.pid}`] : []), ...(w.launchDir ? [`lancée depuis ${w.launchDir}`] : [])].join(', ');
+        return `  - vague ${w.wave} (${where}) : ${w.lots.length ? [...w.lots.map((l) => `${l.key} (${l.status})`), ...w.others.map((l) => `${l.key} (${l.status}, pas en cours au plan)`)].join(', ') : 'lots illisibles'}`;
+    });
+    const how = open.map((w) => w.live
+        ? `  vague ${w.wave} : orchestration en cours, à attendre (le verrou du dépôt tombe dès que tous ses lots y sont prêts ou rendus)`
+        : `  cd ${shellPath(w.launchDir)} && cadence orchestrate --resume ${w.wave}${[...w.lots, ...w.others].map((l) => ` --drop ${l.key}`).join('')}`);
+    return [
+        `spec reseal : refusé — ${open.length > 1 ? `${open.length} vagues non terminées gardent` : 'une vague non terminée garde'} ouvert au moins un lot en cours de ce dépôt (un rescellé commité maintenant lui serait rendu comme « premier commit fautif » à la reprise de la vague) :`,
+        ...lines,
+        'Marche à suivre : clore chacun de ces lots dans sa vague (attendre les vivantes, retirer les lots des arrêtées), puis relancer le rescellé :',
+        ...how,
+    ].join('\n');
+}
+/**
+ * Les vagues non terminées qui gardent ouvert un lot de `repo` encore en cours au plan (L238). Une vague range son état dans le dossier d'où elle a été lancée (`RunStore.runsDir(cwd)`),
+ * souvent un dossier PARENT du dépôt (le dossier des projets) : on remonte donc de la racine du plan jusqu'à la racine du disque.
+ */
+function unfinishedWaves(root, repo, plan) {
+    const launchDirs = new Set();
+    for (let d = resolve(root); !launchDirs.has(d); d = dirname(d))
+        launchDirs.add(d);
+    launchDirs.add(repo);
+    const doing = new Set(plan.lots().filter((l) => l.status === 'doing').map((l) => l.id));
+    const alive = liveWaves(cadenceHome());
+    return [...launchDirs].flatMap((dir) => openWavesIn(dir, repo, (l) => doing.has(l.lot), alive));
+}
+/** La vague qui tient le verrou du dépôt rejoint la liste des vagues en cause, même quand l'état de ses lots ne dit rien (illisible, ou lots absents du plan) : le refus est unique et la nomme toujours. */
+function withHolder(open, holder, repo) {
+    const known = open.find((w) => w.wave === holder.wave);
+    if (known)
+        return open.map((w) => (w === known ? { ...w, live: true, pid: holder.pid } : w));
+    const reg = liveWaves(cadenceHome()).find((w) => w.pid === holder.pid);
+    const keys = openLotsIn(cadenceHome(), holder.pid, repo) ?? [];
+    return [{ wave: holder.wave, launchDir: reg?.cwd ?? '', live: true, pid: holder.pid, lots: keys.map((key) => ({ key, status: 'ouvert' })), others: [] }, ...open];
+}
 function specReseal(args, reason, porteur, ctx, io) {
     if (args.length !== 2 || !reason?.trim())
         throw new RafError('usage : cadence spec reseal <lot> <test> --reason "pourquoi le test contredit la fiche" [--porteur <lot en cours>, pour un lot livré]');
     if (io.env.CADENCE_ORCHESTRATED)
         throw new RafError(`spec reseal refusé pendant une vague orchestrée (${io.env.CADENCE_ORCHESTRATED}) : c'est le travail du lead, hors session`);
     // Comme `deliver` : la vague tient le verrou du dépôt tant qu'un de ses lots y travaille (état illisible : on refuse) ; un commit du lead en pleine passe ferait signaler au lot suivant un écart qui n'est pas le sien.
+    // Le refus est UN message : la vague vivante qui tient le verrou (à attendre) et les vagues arrêtées du dépôt, avec leurs dossiers et leurs commandes (L238).
     const orchestrating = waveHolding(ctx.root);
-    if (orchestrating)
-        throw new RafError(`spec reseal : orchestration en cours (vague ${orchestrating.wave}, pid ${orchestrating.pid}) — rescellé une fois les lots de ce dépôt finis (le verrou tombe dès que tous sont prêts ou rendus)`);
+    if (orchestrating) {
+        const repo = gitRoot(ctx.root) ?? ctx.root;
+        let open = [];
+        try {
+            open = unfinishedWaves(ctx.root, repo, ctx.loadPlan());
+        }
+        catch {
+            // plan illisible : le verrou seul motive le refus, la vague qui le tient est nommée
+        }
+        throw new RafError(openWavesRefusal(withHolder(open, orchestrating, repo)));
+    }
     const [lotId, test] = args;
     const plan = ctx.loadPlan();
     const lot = plan.lot(lotId);
@@ -863,6 +1048,11 @@ function specReseal(args, reason, porteur, ctx, io) {
     const cite = livre ? porteur : lotId;
     if (!json)
         throw new RafError(`${lotId} : aucune acceptation sous ${dir} (le lot n'a pas passé l'étape accept)`);
+    // Une vague non terminée (arrêtée sur une question ou le quota) garde ouverts des lots que son `--resume` rejouera : un rescellé commité entre-temps serait rendu à l'un d'eux comme « premier commit fautif » (L238).
+    // Le verrou du rescellé couvre tous les lots ouverts du dépôt, pas seulement le porteur : on refuse dès qu'un lot DE CE DÉPÔT, encore en cours au plan, reste ouvert dans une vague non terminée.
+    const open = unfinishedWaves(ctx.root, repo, plan);
+    if (open.length)
+        throw new RafError(openWavesRefusal(open));
     const before = { json: readFileSync(join(repo, json), 'utf8'), test: existsSync(join(repo, test)) ? readFileSync(join(repo, test), 'utf8') : '' };
     let r;
     try {
@@ -914,6 +1104,32 @@ function specReseal(args, reason, porteur, ctx, io) {
     io.out(`${lotId} : ${norm} rescellé (${r.avant.slice(0, 7)} → ${r.apres.slice(0, 7)}), commit ${sha}${r.ficheAmendee ? `, fiche amendée en ${r.ficheAmendee}` : ''} ; raison dans ${json} et en note du lot ${cite}${tracked ? '' : ' (plan à commiter)'}`);
     return 0;
 }
+/** Durée par défaut (minutes) d'une session du lead inscrite par `lead hold` : de quoi finir un correctif ou une revue, pas de quoi oublier la réservation toute la journée. */
+const HOLD_TTL_MINUTES = 60;
+/** Longueur maximale de l'étiquette encodée : un nom de fichier tient en 255 octets, `.json.tmp` en prend 9. */
+const HOLD_LABEL_MAX = 200;
+/** `cadence lead hold <étiquette> [--ttl minutes]` / `lead release <étiquette>` (L255) : inscrit, ou rend, une session lancée à la main par le lead, qui compte dans les créneaux libres. */
+function leadHold(rest, ttl, io) {
+    const [verb, label] = rest;
+    const usage = verb === 'hold' ? 'usage : cadence lead hold <étiquette> [--ttl minutes]' : 'usage : cadence lead release <étiquette>';
+    if (rest.length !== 2 || !label.trim())
+        throw new RafError(usage);
+    if (verb === 'release') {
+        if (ttl !== undefined)
+            throw new RafError(`--ttl ne va qu'avec lead hold (${usage})`);
+        io.out(releaseHold(cadenceHome(), label) ? `session « ${label} » rendue` : `aucune session « ${label} » inscrite`);
+        return 0;
+    }
+    // le nom de fichier encode l'étiquette (6 octets par lettre accentuée) : au-delà, le système de fichiers refuse (ENAMETOOLONG)
+    if (encodeURIComponent(label).length > HOLD_LABEL_MAX)
+        throw new RafError(`étiquette trop longue (${usage})`);
+    const minutes = ttl === undefined ? HOLD_TTL_MINUTES : Number(ttl);
+    if (!(Number.isInteger(minutes) && minutes >= 1))
+        throw new RafError(`--ttl invalide : ${ttl} (un nombre entier de minutes ≥ 1)`);
+    addHold(cadenceHome(), label, minutes, io.now());
+    io.out(`session « ${label} » inscrite pour ${minutes} min : elle compte dans les créneaux libres (cadence lead release « ${label} » à sa fin)`);
+    return 0;
+}
 /** `cadence spec check|qa <fiche>` (L170) : code 0 valide, 1 écarts, 2 usage ou fichier illisible. `qa` imprime la section expectations.md de l'écran. */
 function spec(rest, io) {
     const sub = rest[0];
@@ -984,6 +1200,56 @@ async function corrections(rest, values, io) {
     io.out(values.json ? JSON.stringify(m, null, 2) : renderReport(m));
     return 0;
 }
+/**
+ * `cadence perf` (L225) : le tableau de bord du workflow, sans modèle ni écriture, lu dans <dossier>/.cadence/runs et les plans des projets du dossier.
+ * Une erreur de saisie ou de lecture sort avec le code 1 (un ⚠ imprimé, 0). `--since` y est un jour qui tronque les fenêtres, non l'instant de `corrections --since`.
+ */
+/** `cadence perf` sur un dossier : lecture seule, une RafError dit pourquoi le dossier n'est pas lisible ; `warn` reçoit les avertissements (stderr de perf). */
+function readPerf(parent, today, since, warn) {
+    // La grille se lit avant tout journal : une grille mal formée refuse la commande sans sortie partielle (R7).
+    const prices = readPerfConfig(join(parent, 'cadence.yaml'));
+    const runsDir = join(parent, '.cadence', 'runs');
+    if (!existsSync(runsDir))
+        throw new RafError(`perf : aucun journal de vague dans ${runsDir}`);
+    const cache = readCache(join(parent, '.cadence', 'corrections.json'));
+    const journals = readJournals(runsDir);
+    const warnings = [];
+    const plans = readPlans(parent, (l) => warnings.push(l));
+    if (plans.size === 0 && warnings.length === 0)
+        warnings.push(`perf : aucun plan sous ${parent}, indicateurs du plan n/d`);
+    const deliveries = readProjectDeliveries(parent, [...plans.keys()]);
+    const failures = readProjectFailedEntries(parent, [...plans.keys()]);
+    const failedDeliveries = new Map([...failures].map(([name, entries]) => [name, entries.map((e) => e.day)]));
+    const result = computePerf({ journals, plans, cache, deliveries, failedDeliveries, failures, prices, windows: perfWindows(today, since), today, since });
+    if (!prices)
+        warnings.push('perf : aucune grille de prix (cadence.yaml perf.prices), coût en euros n/d');
+    for (const [model, lots] of Object.entries(result.cost.withoutPrice))
+        warnings.push(`perf : modèle sans prix dans perf.prices : ${model}, coût n/d pour ${lots} lot(s)`);
+    warnings.forEach(warn);
+    return result;
+}
+function perf(rest, values, today, io) {
+    try {
+        if (rest.length > 1)
+            throw new RafError('usage : cadence perf [dossier] [--since date] [--json]');
+        if (values.since !== undefined && Number.isNaN(Date.parse(values.since)))
+            throw new RafError(`--since invalide : ${values.since} (une date ISO, ex. 2026-10-10T18:31Z)`);
+        const parent = resolve(io.cwd, rest[0] ?? '.');
+        const result = readPerf(parent, today, values.since, io.err);
+        if (values.json)
+            io.out(JSON.stringify(result, null, 2));
+        else
+            for (const l of renderPerf(result))
+                io.out(l);
+        return 0;
+    }
+    catch (e) {
+        if (!(e instanceof RafError))
+            throw e;
+        io.err(`raf: ${e.message}`);
+        return 1;
+    }
+}
 /** `session start|close --all [--depth n]` : la commande jouée dans chaque projet sous le dossier courant, une section par projet. */
 async function sessionAll(rest, values, io) {
     const sub = rest[0];
@@ -1002,7 +1268,7 @@ async function sessionAll(rest, values, io) {
         throw new RafError(`--idle invalide : ${values.idle}`);
     const projects = findProjects(io.cwd, depth);
     if (projects.length === 0) {
-        io.out(`aucun projet sous ${io.cwd} (docs/plan/raf.yaml ou cadence.yaml avec plan:)`);
+        io.out(`aucun projet sous ${io.cwd} (.cadence/raf.yaml, docs/plan/raf.yaml ou cadence.yaml avec plan:)`);
         return 0;
     }
     const argv = ['session', sub, ...(values.since === undefined ? [] : [`--since=${values.since}`]), ...(values.idle === undefined ? [] : ['--idle', values.idle])];
@@ -1018,7 +1284,7 @@ async function sessionAll(rest, values, io) {
             continue;
         }
         try {
-            code = await run(argv, { ...io, cwd: dir, err: (l) => io.out(`✗ ${l}`) });
+            code = await run(argv, { ...io, cwd: dir, err: (l) => io.out(`✗ ${l}`), notice: io.notice ?? io.err });
         }
         catch (e) {
             io.out(`✗ ${e instanceof Error ? e.message : String(e)}`);