@sylad/cadence 1.1.0 → 1.2.0

package/dist/cli.js

@@ -1,7 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
-import { basename, dirname, join, relative, resolve } from 'node:path';
+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, readPlanConfig, readSessionConfig } from './config.js';
+import { readDocsConfig, readHookConfig, readNewsConfig, readOrchestrateConfig, readPlanConfig, readSessionConfig } from './config.js';
 import { repoSections, repoShas, resolveLotRepos } from './repos.js';
 import { audit, exemptPlanOnly, hypothesesOf, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
 import { short } from './check.js';
@@ -13,15 +14,16 @@ import { gitRoot, readCommits, matchesHead, resolveCommit, stage, stagedFiles, s
 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, STATUSES } from './plan.js';
+import { 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, tourLine } from './lead.js';
+import { findProjects, leadTour, readLeadUx, tourLine } from './lead.js';
 import { liveLines, orchestrate, realOrchestrateDeps } from './orchestrate/command.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 { findAcceptation, resealAcceptation } from './orchestrate/accept.js';
 import { checkFiche, deriveQa, readFiche, summary } from './spec.js';
 import { readHudContext } from './hud-context.js';
 import { sessionClose, sessionStart } from './session.js';
@@ -29,8 +31,10 @@ 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]] [--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] [--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 (l'étape spec d'orchestrate)
+  raf spec <id> on|off   pose ou retire spec: d'un lot existant (le lot change un comportement : étape spec back d'orchestrate)
   raf start <id>        raf done <id> [--force]        raf drop <id> [--reason texte]
   raf note <id> "texte"
   raf did <id> ["texte"]   un lot récurrent (--every) a été refait : le « dû depuis N j » repart de aujourd'hui
@@ -47,7 +51,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf gantt [-o docs/plan/gantt.html]
   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] [--answer projet:lot "réponse"] [--drop projet:lot] ; --drop projet:lot [--wave vague] ; --stop-after-current [--wave vague]
-  cadence lead tour [dossier] [--idle 3] [--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 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 corrections [dossier] [--classify [--model m]] [--cache fichier] [--sample n] [--until 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 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 … »)
@@ -110,6 +114,7 @@ function dispatch(argv, io) {
             quickwin: { type: 'boolean' },
             visible: { type: 'boolean' },
             screen: { type: 'string' },
+            spec: { type: 'boolean' },
             public: { type: 'string' },
             every: { type: 'string' },
             dir: { type: 'string' },
@@ -146,7 +151,7 @@ function dispatch(argv, io) {
         io.out(HELP);
         return 0;
     }
-    if (command !== 'session' && (values.all || values.depth !== undefined))
+    if (command !== 'session' && !(command === 'lead' && !values.all) && (values.all || values.depth !== undefined))
         throw new RafError(`${values.all ? '--all' : '--depth'} ne va qu'avec session start ou session close`);
     const today = io.env.RAF_TODAY ?? toDay(io.now());
     if (!isDay(today))
@@ -155,14 +160,17 @@ function dispatch(argv, io) {
     // 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] !== 'tour' || rest.length > 2)
-            throw new RafError('usage : cadence lead tour [dossier] [--idle 3] [--json]');
+            throw new RafError('usage : cadence lead tour [dossier] [--idle 3] [--depth n] [--json]');
         const idle = values.idle === undefined ? undefined : Number(values.idle);
         if (idle !== undefined && !(Number.isInteger(idle) && idle >= 0))
             throw new RafError(`--idle invalide : ${values.idle}`);
+        const depth = values.depth === undefined ? undefined : Number(values.depth);
+        if (depth !== undefined && !(Number.isInteger(depth) && depth >= 1))
+            throw new RafError(`--depth invalide : ${values.depth} (un entier ≥ 1)`);
         const parent = resolve(io.cwd, rest[1] ?? '.');
         if (!existsSync(parent))
             throw new RafError(`lead tour : dossier introuvable : ${parent}`);
-        const rows = leadTour(parent, today, idle);
+        const rows = leadTour(parent, today, idle, depth);
         if (values.json)
             io.out(JSON.stringify(rows, null, 2));
         else if (rows.length === 0)
@@ -174,13 +182,25 @@ function dispatch(argv, io) {
             const [slots] = liveLines();
             if (slots)
                 io.out(slots);
+            // 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')
+                    io.out('verdict UX : lead (le lead pose raf ux d\'après le rapport du ux-reviewer et les captures ; l\'humain n\'est consulté qu\'en cas de doute)');
+            }
+            catch (e) {
+                // un cadence.yaml illisible a déjà sa ligne d'erreur en tête de tour
+                if (/lead\.ux/.test(e.message))
+                    io.out(`cadence.yaml · ✗ erreur : ${e.message.replace(/^.*cadence\.yaml : /, '')}`);
+            }
         }
         return 0;
     }
     if (command === 'corrections')
         return corrections(rest, values, io);
-    if (command === 'spec')
+    // `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);
+    const reseal = command === 'spec' && rest[0] === 'reseal';
     // --all balaie les sous-dossiers : il ne lit ni le plan ni le cadence.yaml du dossier courant.
     if (command === 'session' && (values.all || values.depth !== undefined))
         return sessionAll(rest, values, io);
@@ -226,6 +246,8 @@ function dispatch(argv, io) {
             if (values.parent) {
                 if (values.screen !== undefined)
                     throw new RafError('--screen se pose sur un lot, pas sur une sous-tâche');
+                if (values.spec)
+                    throw new RafError('--spec se pose sur un lot, pas sur une sous-tâche');
                 if (values.public !== undefined)
                     throw new RafError('--public se pose sur un lot, pas sur une sous-tâche');
                 if (values.every !== undefined)
@@ -242,7 +264,7 @@ 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, public: values.public, every, after });
+                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, screen: values.screen, spec: values.spec, public: values.public, every, after });
             }
             plan.save();
             io.out(id);
@@ -303,6 +325,30 @@ function dispatch(argv, io) {
             plan.save();
             return 0;
         }
+        case 'screen': {
+            need(2, 'screen <id> page|component|journey|none');
+            if (rest.length > 2)
+                throw new RafError('usage : raf screen <id> page|component|journey|none');
+            const plan = loadPlan();
+            if (rest[1] !== 'none' && !SCREENS.includes(rest[1]))
+                throw new RafError(`screen inconnu : ${rest[1]} (${SCREENS.join(', ')}, none)`);
+            plan.setScreen(rest[0], rest[1] === 'none' ? null : rest[1]);
+            plan.save();
+            return 0;
+        }
+        case 'spec': {
+            if (reseal)
+                return specReseal(rest.slice(1), values.reason, { root, loadPlan, configPath, today }, io);
+            if (rest.length !== 2 || (rest[1] !== 'on' && rest[1] !== 'off'))
+                throw new RafError('usage : raf spec <id> on|off (ou cadence spec check|qa <fiche.yaml>)');
+            const plan = loadPlan();
+            if (!plan.setSpec(rest[0], rest[1] === 'on')) {
+                io.out(`${rest[0]} a déjà screen: — l'écran implique la spec, rien à changer`);
+                return 0;
+            }
+            plan.save();
+            return 0;
+        }
         case 'ux':
         case 'review':
             return gate(command, rest, loadPlan, root, today, io);
@@ -338,6 +384,8 @@ function dispatch(argv, io) {
                 io.out(`public : ${lot.public}`);
             if (lot.screen)
                 io.out(`screen : ${lot.screen}`);
+            if (lot.spec)
+                io.out('spec : true');
             if (notes.length) {
                 io.out('notes :');
                 // Les lignes suivantes d'une note multiligne s'alignent sous son texte, pas en colonne 0.
@@ -447,10 +495,8 @@ function dispatch(argv, io) {
         case 'deliver': {
             if (!gitRoot(io.cwd))
                 throw new RafError('deliver : à lancer dans un dépôt git');
-            const orchestrating = activeLock(join(sharedStateDir(root), REPO_LOCK));
-            // La vague tient le verrou jusqu'à la fin de ses lots ; ne refuse que si l'un d'eux travaille encore dans CE dépôt (état illisible : on refuse).
-            const stillOpen = orchestrating ? openLotsIn(cadenceHome(), orchestrating.pid, root) : null;
-            if (orchestrating && (stillOpen === null || stillOpen.length > 0))
+            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 (!existsSync(configPath))
                 throw new RafError(`pas de configuration de livraison : ${configPath} (voir « cadence.yaml » dans le README)`);
@@ -753,6 +799,90 @@ function morningEffects(configPath, root) {
         return [`✗ ${e.message}`];
     }
 }
+/** La vague qui tient le verrou du dépôt tant qu'un de ses lots y travaille encore (état illisible : on la tient pour active) ; null si le dépôt est libre. Partagé par `deliver` et `spec reseal`. */
+function waveHolding(root) {
+    const orchestrating = activeLock(join(sharedStateDir(root), REPO_LOCK));
+    if (!orchestrating)
+        return null;
+    const stillOpen = openLotsIn(cadenceHome(), orchestrating.pid, root);
+    return stillOpen === null || stillOpen.length > 0 ? orchestrating : null;
+}
+/**
+ * `cadence spec reseal <lot> <test> --reason texte` (L200) : le chemin du lead quand un test d'acceptation scellé du lot EN COURS contredit la fiche.
+ * Le test est corrigé dans l'arbre de travail (fiche inchangée) ; la commande refait l'empreinte de ce seul test, journalise la raison dans
+ * 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'] });
+function specReseal(args, reason, ctx, io) {
+    if (args.length !== 2 || !reason?.trim())
+        throw new RafError('usage : cadence spec reseal <lot> <test> --reason "pourquoi le test contredit la fiche"');
+    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.
+    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)`);
+    const [lotId, test] = args;
+    const plan = ctx.loadPlan();
+    const lot = plan.lot(lotId);
+    if (lot.status !== 'doing')
+        throw new RafError(`${lotId} n'est pas en cours (${lot.status}) : le rescellé ne vaut que pour le lot en cours ; un lot livré évolue avec sa fiche (README, « Exception — a delivered lot »)`);
+    const repo = gitRoot(ctx.root) ?? ctx.root;
+    const dir = readOrchestrateConfig(ctx.configPath).spec.dir;
+    const json = findAcceptation(repo, dir, lotId);
+    if (!json)
+        throw new RafError(`${lotId} : aucune acceptation sous ${dir} (le lot n'a pas passé l'étape accept)`);
+    const before = { json: readFileSync(join(repo, json), 'utf8'), test: existsSync(join(repo, test)) ? readFileSync(join(repo, test), 'utf8') : '' };
+    let r;
+    try {
+        r = resealAcceptation(repo, json, test, reason, ctx.today);
+    }
+    catch (e) {
+        throw new RafError(e.message);
+    }
+    const norm = posix.normalize(test);
+    try {
+        git(repo, ['add', '--', json, norm]);
+        git(repo, ['commit', '-q', '-m', `test(${lotId}): acceptation rescellée, ${norm} : ${reason.trim()}`, '--', json, norm]);
+    }
+    catch (e) {
+        // Atomique : un commit refusé (hook pre-commit, ...) ne laisse ni empreinte refaite ni index à moitié prêt ; le test retrouve le texte du lead.
+        writeFileSync(join(repo, json), before.json);
+        writeFileSync(join(repo, norm), before.test);
+        try {
+            git(repo, ['reset', '-q', '--', json, norm]);
+        }
+        catch {
+            // rien d'indexé : rien à défaire
+        }
+        const out = e;
+        throw new RafError(`spec reseal : le commit du rescellé a échoué, ${json} et ${norm} sont revenus tels qu'avant la commande (rien n'est rescellé) — ${(out.stderr || out.stdout || out.message).trim().split('\n').slice(-5).join(' | ')}`);
+    }
+    const sha = git(repo, ['rev-parse', '--short', 'HEAD']).trim();
+    // Un plan tenu par un autre outil ne se modifie pas d'ici : la raison est déjà dans acceptation.json et dans le commit, la note reste à la main du lead.
+    if (plan.readonly) {
+        io.out(`${lotId} : ${norm} rescellé (${r.avant.slice(0, 7)} → ${r.apres.slice(0, 7)}), commit ${sha} ; raison dans ${json} et dans le commit — note à ajouter au lot avec l'outil du projet (plan en lecture seule)`);
+        return 0;
+    }
+    plan.note(lotId, `test d'acceptation rescellé (${norm}, fiche inchangée) : ${reason.trim()}`, ctx.today);
+    plan.save();
+    // La note du lot rejoint le dépôt dans la foulée (un dépôt sale arrêterait la vague suivante) ; un plan hors du dépôt ou non suivi reste à la main du lead.
+    const planRel = relative(repo, plan.path);
+    const tracked = !planRel.startsWith('..') && git(repo, ['ls-files', '--', planRel]).trim() !== '';
+    if (tracked) {
+        try {
+            git(repo, ['add', '--', planRel]);
+            git(repo, ['commit', '-q', '-m', `plan: ${lotId} test d'acceptation rescellé (${norm})`, '--', planRel]);
+        }
+        catch (e) {
+            // Le rescellé est fait (commit ${sha}) : on ne le défait pas, on dit où en est la note, au lieu d'une pile d'appels.
+            const out = e;
+            throw new RafError(`spec reseal : le rescellé a eu lieu (commit ${sha}) mais le commit de la note du lot a échoué — la note est écrite dans ${planRel}, à commiter à la main (un plan sale arrêterait la vague suivante) — ${(out.stderr || out.stdout || out.message).trim().split('\n').slice(-5).join(' | ')}`);
+        }
+    }
+    io.out(`${lotId} : ${norm} rescellé (${r.avant.slice(0, 7)} → ${r.apres.slice(0, 7)}), commit ${sha} ; raison dans ${json} et en note du lot${tracked ? '' : ' (plan à commiter)'}`);
+    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];

package/dist/config.js

@@ -220,13 +220,13 @@ export function readSessionConfig(file) {
     return config;
 }
 const EFFORTS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
-export const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'accept', 'implement', 'fix', 'review', 'ux'];
+export const EFFORT_STEPS = ['precheck', 'spec', 'maquette', 'fiche', 'accept', 'implement', 'fix', 'review', 'ux'];
 const MODELS = ['haiku', 'sonnet', 'opus'];
 const REVIEW_KEYS = ['threshold', 'light', 'full'];
-const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'accept', 'maquette', 'ux', 'precheck', 'prodAccess', 'spec', 'review', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'accept', 'maquette', 'fiche', 'ux', 'precheck', 'prodAccess', 'spec', 'review', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
 /** Clé `orchestrate:` de cadence.yaml. Absente : les défauts (auto, 45 min d'implémentation, 25 min de revue). */
 export function readOrchestrateConfig(file) {
-    const config = { precheck: true, maquette: true, precheckLocal: false, prodAccess: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', accept: 'medium', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
+    const config = { precheck: true, maquette: true, fiche: true, precheckLocal: false, prodAccess: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', fiche: 'medium', accept: 'medium', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
     if (!existsSync(file))
         return config;
     let raw;
@@ -253,7 +253,14 @@ export function readOrchestrateConfig(file) {
     for (const k of Object.keys(o))
         if (!ORCH_KEYS.includes(k))
             throw bad(`${k} inconnu (attendu : ${ORCH_KEYS.join(', ')})`);
+    if (o.accept != null && Array.isArray(o.accept)) {
+        if (!o.accept.length || o.accept.some((x) => typeof x !== 'string' || !x.trim()))
+            throw bad('accept : commande non vide attendue (chaîne ou liste de commandes non vides)');
+        config.accept = o.accept.map((x) => x.trim());
+    }
     for (const k of ['start', 'verdict', 'test', 'build', 'accept']) {
+        if (k === 'accept' && Array.isArray(o.accept))
+            continue;
         if (o[k] == null)
             continue;
         if (typeof o[k] !== 'string' || !o[k].trim())
@@ -265,6 +272,11 @@ export function readOrchestrateConfig(file) {
             throw bad('maquette : true ou false attendu');
         config.maquette = o.maquette;
     }
+    if (o.fiche != null) {
+        if (typeof o.fiche !== 'boolean')
+            throw bad('fiche : true ou false attendu');
+        config.fiche = o.fiche;
+    }
     if (o.precheck != null) {
         if (typeof o.precheck !== 'boolean' && o.precheck !== 'local')
             throw bad('precheck : true, false ou local attendu');
@@ -318,7 +330,7 @@ export function readOrchestrateConfig(file) {
     }
     if (o.effort != null) {
         if (!isObject(o.effort))
-            throw bad('effort doit être un objet { precheck, spec, maquette, accept, implement, fix, review, ux }');
+            throw bad('effort doit être un objet { precheck, spec, maquette, fiche, accept, implement, fix, review, ux }');
         for (const [k, v] of Object.entries(o.effort)) {
             if (!EFFORT_STEPS.includes(k))
                 throw bad(`effort.${k} inconnu (attendu : ${EFFORT_STEPS.join(', ')})`);

package/dist/lead.js

@@ -1,13 +1,58 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import { basename, join } from 'node:path';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, join, relative, sep } from 'node:path';
 import { audit, nextUp, planCommits } from './audit.js';
 import { planLoader, readPlanConfig } from './config.js';
 import { diffDays } from './dates.js';
 import { gitRoot, repoStatus } from './git.js';
 import { linkCommits } from './link.js';
 import { lastActivity, lockStatus } from './session.js';
+import { parse } from 'yaml';
+import { RafError } from './plan.js';
 import { priorityRank, readPriority } from './orchestrate/continue.js';
 import { readNext, sharedStateDir, stateDir } from './state.js';
+/** Clé `lead.ux` du cadence.yaml du dossier parent (L197) : qui pose le verdict UX (`raf ux`) d'un lot visible. `human` (défaut) : l'humain ; `lead` : le lead, l'humain n'étant consulté qu'en cas de doute. */
+export function readLeadUx(parent) {
+    const file = join(parent, 'cadence.yaml');
+    if (!existsSync(file))
+        return 'human';
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const l = raw?.lead;
+    if (l == null)
+        return 'human';
+    const ux = l.ux;
+    if (typeof l !== 'object' || Array.isArray(l))
+        throw new RafError(`${file} : lead.ux doit être « lead » ou « human »`);
+    if (ux == null)
+        return 'human';
+    if (ux !== 'lead' && ux !== 'human')
+        throw new RafError(`${file} : lead.ux doit être « lead » ou « human »`);
+    return ux;
+}
+/** Clé `depth:` du cadence.yaml du dossier parent (L201, issue #8), à côté de `priority:` : combien de niveaux `lead tour` parcourt (1 : sous-dossiers directs, le défaut). */
+export function readDepth(parent) {
+    const file = join(parent, 'cadence.yaml');
+    if (!existsSync(file))
+        return 1;
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const d = raw?.depth;
+    if (d == null)
+        return 1;
+    if (typeof d !== 'number' || !Number.isInteger(d) || d < 1)
+        throw new RafError(`${file} : depth doit être un entier ≥ 1`);
+    return d;
+}
 export const NOTES_MAX = 120;
 export const TITLE_MAX = 60;
 /** Au-delà de ce nombre de jours sans activité, un lot en cours est dit silencieux. */
@@ -56,8 +101,8 @@ export function findProjects(parent, depth = 1) {
     return found.sort();
 }
 /** Les faits de `cadence session start` pour un projet, sous forme de données ; lecture seule. */
-export function tourRow(dir, today, idle = TOUR_IDLE) {
-    const row = empty(basename(dir));
+export function tourRow(dir, today, idle = TOUR_IDLE, name = basename(dir)) {
+    const row = empty(name);
     try {
         const root = gitRoot(dir) ?? dir;
         const plan = planLoader(root)();
@@ -96,24 +141,32 @@ export function tourRow(dir, today, idle = TOUR_IDLE) {
 }
 /**
  * Les projets rangés par la clé `priority:` du cadence.yaml du dossier (L149) ; les autres après, par ordre alphabétique.
- * Une priorité illisible ou invalide ne vide pas le tableau : l'ordre alphabétique reste, et une première ligne `cadence.yaml` en erreur le dit.
+ * Une clé `depth:` invalide se signale de même. Une priorité illisible ou invalide ne vide pas le tableau : l'ordre alphabétique reste, et une première ligne `cadence.yaml` en erreur le dit.
  * Un dossier qui n'a aucun sous-projet mais est lui-même un projet donne la ligne de ce projet seul (la bande l'interroge depuis le dossier de la session).
  */
-export function leadTour(parent, today, idle = TOUR_IDLE) {
-    const dirs = findProjects(parent);
+export function leadTour(parent, today, idle = TOUR_IDLE, depth) {
+    const problems = [];
+    const attempt = (read, fallback) => {
+        try {
+            return read();
+        }
+        catch (e) {
+            const error = (e instanceof Error ? e.message : String(e)).split('\n')[0];
+            if (!problems.some((p) => p.error === error))
+                problems.push({ ...empty('cadence.yaml'), error }); // un yaml illisible l'est pour les deux clés : une seule ligne
+            return fallback;
+        }
+    };
+    // --depth l'emporte sur la clé `depth:` ; une clé invalide se signale et laisse un seul niveau
+    const levels = depth ?? attempt(() => readDepth(parent), 1);
+    const dirs = findProjects(parent, levels);
     if (dirs.length === 0 && isProject(parent))
-        return [tourRow(parent, today, idle)];
-    const rows = dirs.map((dir) => tourRow(dir, today, idle));
-    let priority = [];
-    let problem;
-    try {
-        priority = readPriority(parent);
-    }
-    catch (e) {
-        problem = { ...empty('cadence.yaml'), error: (e instanceof Error ? e.message : String(e)).split('\n')[0] };
-    }
-    const sorted = rows.map((r, i) => ({ r, i })).sort((a, b) => priorityRank(a.r.project, priority) - priorityRank(b.r.project, priority) || a.i - b.i).map((x) => x.r);
-    return problem ? [problem, ...sorted] : sorted;
+        return [...problems, tourRow(parent, today, idle)];
+    // un projet imbriqué est nommé par son chemin depuis le dossier : unique, et adressable par `orchestrate <projet>:<lot>` lancé d'ici ; la priorité et l'ordre alphabétique lisent le nom du dossier, comme orchestrate --continue
+    const rows = dirs.map((dir) => ({ dir, key: basename(dir), row: tourRow(dir, today, idle, relative(parent, dir).split(sep).join('/')) }));
+    const priority = attempt(() => readPriority(parent), []);
+    const sorted = rows.sort((a, b) => priorityRank(a.key, priority) - priorityRank(b.key, priority) || a.key.localeCompare(b.key) || a.row.project.localeCompare(b.row.project)).map((x) => x.row);
+    return [...problems, ...sorted];
 }
 const DRIFT_SHOWN = 2;
 /** Une ligne par projet : projet · en cours · dérive · notes · prochain lot prêt · dépôt. */

package/dist/orchestrate/accept.js

@@ -49,7 +49,8 @@ export function parseAcceptation(text) {
     if (typeof vert !== 'boolean')
         return 'clé « vert » (booléen) attendue';
     const empreintes = isObj(doc.empreintes) ? Object.fromEntries(Object.entries(doc.empreintes).filter(([, v]) => typeof v === 'string')) : undefined;
-    return { lot, fiche, fichiers: fichiers, vert, ...(empreintes ? { empreintes } : {}) };
+    const resceaux = Array.isArray(doc.resceaux) ? doc.resceaux.filter((r) => isObj(r) && ['test', 'raison', 'date', 'avant', 'apres'].every((k) => typeof r[k] === 'string')) : undefined;
+    return { lot, fiche, fichiers: fichiers, vert, ...(empreintes ? { empreintes } : {}), ...(resceaux?.length ? { resceaux } : {}) };
 }
 /** JSON à clés triées, sans la clé `vert` : la forme que le verrou compare. */
 const canon = (a) => JSON.stringify(Object.fromEntries(Object.entries(a).filter(([k]) => k !== 'vert').sort(([x], [y]) => x.localeCompare(y))));
@@ -81,6 +82,22 @@ export function redSha(repo, path) {
     }
     return null;
 }
+/**
+ * Le commit rouge a bougé depuis `anchor` par un rescellé du lead (`cadence spec reseal`, L200) : le nouveau sha, sinon null.
+ * Seul un commit qui a allongé le journal `resceaux` ET qu'aucune session de la vague n'a fait (`bySession`) est adopté ; toute autre réécriture reste un écart pour le verrou.
+ */
+export function resealedRouge(repo, path, anchor, bySession = () => false) {
+    const now = redSha(repo, path);
+    if (!now || now === anchor)
+        return null;
+    if (bySession(now))
+        return null; // un commit de session n'est jamais un rescellé du lead : il reste un écart pour le verrou
+    const journal = (rev) => {
+        const r = show(repo, rev, path)?.resceaux;
+        return Array.isArray(r) ? r.length : 0;
+    };
+    return journal(now) > journal(anchor) ? now : null;
+}
 /** Chemin (relatif au dépôt) de l'`acceptation.json` du lot sous `dir`, ou null. */
 export function findAcceptation(repo, dir, lot) {
     for (const path of listAcceptations(repo, dir).sort()) {
@@ -103,6 +120,45 @@ export function sealAcceptation(repo, path) {
     doc.empreintes = Object.fromEntries(fichiers.map((f) => [f, git(repo, 'hash-object', '--', f).trim()]));
     writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`);
 }
+/**
+ * Rescelle UN test (L200, `cadence spec reseal`, le lead — jamais une session) : le test d'un lot en cours contredit sa fiche et le verrou total
+ * ne laisse aucun chemin de correction. La fiche reste inchangée depuis le commit rouge, les autres fichiers listés aussi : seule l'empreinte
+ * du test nommé est refaite, la raison et les deux empreintes vont dans `resceaux`. Le commit (test + acceptation) est à faire : il devient le commit rouge.
+ */
+export function resealAcceptation(repo, path, test, reason, today) {
+    const file = join(repo, path);
+    const a = parseAcceptation(readFileSync(file, 'utf8'));
+    if (typeof a === 'string')
+        throw new Error(`${path} : ${a}`);
+    if (!reason.trim())
+        throw new Error('--reason est obligatoire : la raison du rescellé va dans acceptation.json et en note du lot');
+    const norm = posix.normalize(test);
+    const fichiers = a.fichiers.map((f) => posix.normalize(f));
+    if (!fichiers.includes(norm))
+        throw new Error(`${test} n'est pas listé dans ${path} (fichiers : ${fichiers.join(', ')})`);
+    const avant = a.empreintes?.[norm];
+    if (!a.empreintes || !avant)
+        throw new Error(`${path} n'est pas scellée (pas d'empreinte pour ${norm}) : l'étape accept n'est pas finie, rien à resceller`);
+    const red = redSha(repo, path);
+    if (!red)
+        throw new Error(`${path} : pas de commit rouge lisible`);
+    if (!existsSync(join(repo, norm)))
+        throw new Error(`${norm} : fichier absent (un test supprimé ne se rescelle pas)`);
+    if (!gitOk(repo, 'diff', '--quiet', red, '--', a.fiche))
+        throw new Error(`la fiche ${a.fiche} a changé depuis le commit rouge ${red.slice(0, 7)} : le rescellé ne vaut que fiche inchangée (une fiche qui évolue passe par le lot et sa revue)`);
+    const touches = fichiers.filter((f) => f !== norm && (!gitOk(repo, 'diff', '--quiet', red, '--', f) || !existsSync(join(repo, f)) || a.empreintes?.[f] !== git(repo, 'hash-object', '--', f).trim()));
+    if (touches.length)
+        throw new Error(`autre(s) test(s) listé(s) modifié(s) depuis le commit rouge : ${touches.join(', ')} (le rescellé ne couvre que ${norm}, le verrou garde le reste)`);
+    const apres = git(repo, 'hash-object', '--', norm).trim();
+    if (apres === avant)
+        throw new Error(`${norm} est inchangé depuis le scellé : rien à resceller`);
+    const doc = JSON.parse(readFileSync(file, 'utf8'));
+    doc.empreintes[norm] = apres;
+    const journal = Array.isArray(doc.resceaux) ? doc.resceaux : [];
+    doc.resceaux = [...journal, { test: norm, raison: reason.trim(), date: today, avant, apres }];
+    writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`);
+    return { avant, apres, lot: a.lot };
+}
 /** Pose `vert: true` dans le fichier (le cycle, jamais une session) ; le commit est à faire. */
 export function setVert(repo, path) {
     const file = join(repo, path);
@@ -288,12 +344,42 @@ export function lockViolations(repo, dir, headBefore, opts = {}) {
     }
     return out;
 }
+/** Une liste (même d'un seul élément) lance chaque entrée sous sa racine ; une chaîne garde le dépôt pour racine. Le brief et le cycle décident par cette seule fonction. */
+export function isAcceptList(accept) {
+    return Array.isArray(accept);
+}
+/** Commandes de `orchestrate.accept` : une chaîne ou une liste (L189), toujours rendue en liste. */
+export function acceptCommands(accept) {
+    return accept === undefined ? [] : isAcceptList(accept) ? accept : [accept];
+}
+/** Racine d'une commande : le dossier de son `cd <dossier> &&` initial (relatif au dépôt, normalisé), sinon le dépôt (''). Un `cd` qui sort du dépôt n'est pas une racine. */
+export function acceptRoot(command) {
+    const m = /^\s*cd\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*&&/.exec(command);
+    const dir = posix.normalize(m?.[1] ?? m?.[2] ?? m?.[3] ?? '.');
+    return dir === '.' || dir === '..' || dir.startsWith('../') || posix.isAbsolute(dir) ? '' : dir.replace(/\/$/, '');
+}
+/** Le fichier est sous la racine (le dépôt, '', contient tout). */
+export const underRoot = (file, root) => {
+    const f = posix.normalize(file);
+    return root === '' || f.startsWith(`${root}/`);
+};
+/** Lancements d'une liste de commandes (`single` : la chaîne seule de `orchestrate.accept`, dont la racine reste le dépôt, `cd` ou non, comme avant la liste) pour les fichiers de l'acceptation : une commande sans fichier sous sa racine n'est pas lancée ; un fichier sous aucune racine est un orphelin. */
+export function planAcceptRuns(commands, fichiers, single = false) {
+    const all = commands.map((command) => ({ command, root: single ? '' : acceptRoot(command) }));
+    return { runs: all.filter((r) => fichiers.some((f) => underRoot(f, r.root))), orphans: fichiers.filter((f) => !all.some((r) => underRoot(f, r.root))) };
+}
 /** Consigne propre à l'étape accept dans le brief : fiche, maquette, commande dédiée, gabarit du lanceur, et les écarts de la passe précédente. */
 export function acceptText(o) {
+    const commands = acceptCommands(o.command);
+    const screen = o.screen !== false;
     const lines = [
-        `Sheet: \`${o.fiche}\` (rules, fields, actions). Mockup: \`${o.maquette}\` (every field carries \`data-testid="<field id>"\`). You get nothing else about the screen: the implementation does not exist yet.`,
-        `The project declares the dedicated command that runs ONLY the acceptance tests of this lot (\`orchestrate.accept\`): \`${o.command}\` (from the repository root; the program sets \`CADENCE_ACCEPTATION\` to the absolute path of the lot's \`acceptation.json\`, and replaces \`{acceptation}\` with it).${o.test ? ` The project's ordinary test command is \`${o.test}\`: it must stay green with your red tests committed.` : ''}`,
-        `Write \`${o.acceptation}\` (one file per lot, next to the sheet: another lot on the same screen has its own, which you never touch, nor its tests — give your test files names of your own): \`{ "lot": "<lot>", "fiche": "${o.fiche}", "fichiers": ["<test file>", …], "vert": false }\` (paths relative to the repository). The ordinary test config of the project (shared with its CI) must exclude those files while \`vert\` is false; the dedicated config includes only them. Both read the file with this runner template (copy it into the project, e.g. \`tests/acceptation-runner.mjs\`):`,
+        !screen
+            ? `Sheet: \`${o.fiche}\` (cases, rules, contracts, data). You get nothing else about the behaviour: the implementation does not exist yet.`
+            : `Sheet: \`${o.fiche}\` (rules, fields, actions). Mockup: \`${o.maquette}\` (every field carries \`data-testid="<field id>"\`). You get nothing else about the screen: the implementation does not exist yet.${o.back ? ' The sheet also has a back part (`cas`, `contrats`, `donnees`): write the cases of its rules too, calling the contracts of `contrats[]` as close as possible and simulating the external sources from `entree`.' : ''}`,
+        isAcceptList(o.command)
+            ? `The project declares several dedicated commands (\`orchestrate.accept\`, one per test runner), each of which runs ONLY the acceptance tests of this lot that sit under its root (the folder of its leading \`cd <folder> &&\`, else the repository): ${commands.map((x) => `\`${x}\` (root \`${acceptRoot(x) || '.'}\`)`).join(', ')}. Each is run from the repository root and gets \`CADENCE_ACCEPTATION\` (the absolute path of the lot's \`acceptation.json\`, also substituted for \`{acceptation}\`) and \`CADENCE_ACCEPTATION_ROOT\` (its root); it takes only the files listed under its root, a command with no listed file under its root is not run, and a listed file under no root is refused. Put each test file where its runner looks, and list every file in \`fichiers\`.${o.test ? ` The project's ordinary test command is \`${o.test}\`: it must stay green with your red tests committed.` : ''}`
+            : `The project declares the dedicated command that runs ONLY the acceptance tests of this lot (\`orchestrate.accept\`): \`${commands[0]}\` (from the repository root; the program sets \`CADENCE_ACCEPTATION\` to the absolute path of the lot's \`acceptation.json\`, and replaces \`{acceptation}\` with it).${o.test ? ` The project's ordinary test command is \`${o.test}\`: it must stay green with your red tests committed.` : ''}`,
+        `Write \`${o.acceptation}\` (one file per lot, next to the sheet: another lot on the same ${screen ? 'screen' : 'subject'} has its own, which you never touch, nor its tests — give your test files names of your own): \`{ "lot": "<lot>", "fiche": "${o.fiche}", "fichiers": ["<test file>", …], "vert": false }\` (paths relative to the repository). The ordinary test config of the project (shared with its CI) must exclude those files while \`vert\` is false; the dedicated config includes only them. Both read the file with this runner template (copy it into the project, e.g. \`tests/acceptation-runner.mjs\`):`,
     ];
     if (o.runner)
         lines.push('```js', o.runner.trimEnd(), '```');