@sylad/cadence 1.40.0 → 1.41.0

package/dist/plan.js

@@ -3,7 +3,11 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync, rmSync } from 'node
 import { dirname, join, relative, resolve } from 'node:path';
 import { dirtyContents } from './git.js';
 import { Document, isMap, isSeq, parseDocument } from 'yaml';
-import { isDay, toDay } from './dates.js';
+import { toDay } from './dates.js';
+import { normalizeLot } from './plan-read.js';
+import { currentState, defaultState, rebase, stateProblems, transitionProblem } from './plan-states.js';
+import { DOCS_OK_FILE, readDocsOkFile } from './docs-ok-file.js';
+import { checkedExtras, withExtras } from './plan-extras.js';
 import { ARCHIVE_DIR, archiveFiles, archiveLots, archiveYear, mergeArchived, newArchiveDoc, readArchiveDoc, selectArchivable } from './archive.js';
 /** Délai de la commande `plan.onWrite` : une republication du plan, pas un build. */
 const ON_WRITE_TIMEOUT_MS = 120_000;
@@ -24,7 +28,6 @@ export function setPlanNotice(fn) {
     notice = fn;
 }
 export const STATUSES = ['todo', 'doing', 'done', 'dropped'];
-const GATE_INVALID = 'gate invalide : count: entier ≥ 1 et un critère spec: true ou screen: page attendus';
 export class RafError extends Error {
 }
 /** Un nom de ressource partagée (L251) : un mot de lettres minuscules, chiffres, « - » et « _ ». */
@@ -391,7 +394,14 @@ export class Plan {
         }
         // L396 : l'archive est un détail de stockage — les lots archivés reprennent leur place parmi ceux du fichier actif, comme un seul plan.
         const archived = this.loadArchives().flatMap((a) => archiveLots(a.doc).toJSON());
-        return mergeArchived(archived.map((r) => normalizeLot(r)), this.activeRaw().map((r) => normalizeLot(r)));
+        const read = (r) => withExtras(normalizeLot(r), r, this.settings.extras);
+        const lots = mergeArchived(archived.map(read), this.activeRaw().map(read));
+        const model = this.settings.states;
+        return model ? lots.map((l) => ({ ...l, problems: [...l.problems, ...stateProblems(model, l)] })) : lots;
+    }
+    /** Les états détaillés déclarés (`plan.states`), ou undefined. */
+    get stateModel() {
+        return this.settings.states;
     }
     lot(id) {
         const found = this.lots().find((l) => l.id === id);
@@ -560,6 +570,7 @@ export class Plan {
         if (opts.every !== undefined && !(Number.isInteger(opts.every) && opts.every > 0)) {
             throw new RafError(`périodicité invalide : ${opts.every} (un nombre entier de jours, 1 au moins)`);
         }
+        const extras = checkedExtras(this.settings.extras, opts.extras);
         const entry = { id, title };
         if (pub !== undefined)
             entry.public = pub;
@@ -573,6 +584,7 @@ export class Plan {
             entry.after = opts.after;
         if (opts.uses?.length)
             entry.uses = cleanUses(opts.uses);
+        Object.assign(entry, extras);
         entry.created = today;
         const node = this.doc.createNode(entry);
         for (const key of ['after', 'uses']) {
@@ -720,6 +732,11 @@ export class Plan {
         if (!isOpen(lot.status)) {
             throw new RafError(`${lotId} est ${lot.status} ; le rouvrir si c'est voulu : raf todo ${lotId}`);
         }
+        const model = this.settings.states;
+        const target = model ? defaultState(model, status) : undefined;
+        const refused = model && target !== undefined && !opts.force ? transitionProblem(model, currentState(model, lot), target) : null;
+        if (refused)
+            throw new RafError(`${lotId} : ${refused} — raf status ${lotId} <état> (--force pour passer outre)`);
         if (status === 'done') {
             const open = lot.tasks.filter((t) => isOpen(t.status)).map((t) => `${lotId}/${t.id}`);
             if (open.length > 0 && !opts.force) {
@@ -738,6 +755,7 @@ export class Plan {
             }
         }
         node.set('status', status);
+        this.syncState(node, status);
         if (!lot.started && status !== 'dropped')
             node.set('started', today);
         if (status === 'done' || status === 'dropped')
@@ -760,6 +778,7 @@ export class Plan {
         if (lot.status === 'done' || lot.status === 'dropped') {
             const node = this.lotNode(ref);
             node.set('status', 'todo');
+            this.syncState(node, 'todo');
             node.delete('finished');
             this.note(ref, reason.trim() ? `rouvert (était ${lot.status}) : ${reason.trim()}` : `rouvert (était ${lot.status})`, today);
             return;
@@ -769,9 +788,78 @@ export class Plan {
             throw new RafError(`${ref} a ${n} commit(s) qui le citent : le remettre en attente perdrait leur lien — raf drop ou le laisser doing`);
         const node = this.lotNode(ref);
         node.set('status', 'todo');
+        this.syncState(node, 'todo');
         node.delete('started');
         this.note(ref, reason.trim() ? `remis en attente : ${reason.trim()}` : 'remis en attente', today);
     }
+    /**
+     * Pose le `state:` d'un lot (`raf status`, L463) sous la garde de `plan.transitions`, et note le message daté. Le statut de base en est
+     * dérivé : seuls todo → doing (le lot démarre) et doing → todo (`started:` retiré ; refusé dès qu'un commit cite le lot, la porte de
+     * `raf todo`) se font ici, pour que l'état bloqué se quitte vers l'état d'avant quel que soit son statut de base ; les autres changements
+     * de base gardent leur commande et leurs portes (`raf done`, `drop`, `todo`). Entrer dans l'état bloqué mémorise l'état d'avant
+     * (`state_before:`), `back` y revient sans garde de transition. `commits` compte les commits qui citent le lot (lu seulement pour doing → todo).
+     */
+    setState(ref, target, today, opts = {}, commits = () => 0) {
+        this.writable();
+        const model = this.settings.states;
+        if (!model)
+            throw new RafError('aucun état déclaré : cadence.yaml plan.states');
+        if (ref.includes('/'))
+            throw new RafError(`raf status se pose sur un lot, pas une sous-tâche : ${ref}`);
+        const lot = this.lot(ref);
+        const from = currentState(model, lot);
+        let to = target ?? '';
+        if (opts.back) {
+            if (!model.blocked)
+                throw new RafError('aucun état bloqué déclaré : cadence.yaml plan.blockedState');
+            if (from !== model.blocked)
+                throw new RafError(`${ref} n'est pas bloqué (état ${from})`);
+            if (!lot.stateBefore)
+                throw new RafError(`${ref} : état d'avant introuvable (state_before: absent) — raf status ${ref} <état>`);
+            if (!Object.hasOwn(model.states, lot.stateBefore))
+                throw new RafError(`${ref} : l'état d'avant « ${lot.stateBefore} » n'est plus déclaré — raf status ${ref} <état>`);
+            to = lot.stateBefore;
+        }
+        else {
+            if (!Object.hasOwn(model.states, to))
+                throw new RafError(`état inconnu : ${to} (déclarés : ${Object.keys(model.states).join(', ')})`);
+            if (to === from)
+                throw new RafError(`${ref} est déjà ${to}`);
+            const refused = transitionProblem(model, from, to);
+            if (refused)
+                throw new RafError(`${ref} : ${refused}`);
+        }
+        const node = this.lotNode(ref);
+        const base = model.states[to];
+        if (base !== lot.status) {
+            const refused = rebase(node, lot, { ref, to, base }, today, commits);
+            if (refused)
+                throw new RafError(refused);
+        }
+        this.writeState(node, to, to === model.blocked ? from : undefined);
+        const message = opts.message?.trim();
+        if (message)
+            this.note(ref, `état ${to} : ${message}`, today);
+        return to;
+    }
+    /** Met l'état d'un lot au diapason de son nouveau statut de base (`start`, `done`, `drop`, `todo`) ; sans `plan.states`, ne touche à rien. */
+    syncState(node, status) {
+        if (this.settings.states)
+            this.writeState(node, defaultState(this.settings.states, status));
+    }
+    /** Écrit `state:` (et `state_before:`) juste après `status:` ; `undefined` retire la clé. */
+    writeState(node, state, before) {
+        for (const [key, value] of [['state', state], ['state_before', before]]) {
+            if (value === undefined)
+                node.delete(key);
+            else if (node.has(key))
+                node.set(key, value);
+            else {
+                const keys = node.items.map((p) => String(p.key?.value ?? p.key));
+                node.items.splice(Math.max(keys.indexOf('status'), keys.indexOf('state')) + 1, 0, this.doc.createPair(key, value));
+            }
+        }
+    }
     /** Remplace le titre d'un lot, de tout statut, et note l'ancien titre ; refuse un titre vide ou identique. */
     setTitle(ref, text, today) {
         this.writable();
@@ -902,28 +990,6 @@ export class Plan {
     }
 }
 /** Lit une liste écrite dans un autre format : champs traduits, entrées à parent repliées en sous-tâches. */
-/** Fichier d'acquittement docs-ok d'un plan en lecture seule, relatif à la racine du dépôt (L386). */
-const DOCS_OK_FILE = '.cadence/docs-ok.yaml';
-/** Les acquittements du fichier : lot → { date, reason }. Une entrée sans raison n'acquitte rien ; un fichier illisible est une erreur qui le nomme. */
-function readDocsOkFile(file) {
-    if (!file || !existsSync(file))
-        return {};
-    const doc = parseDocument(readFileSync(file, 'utf8'));
-    if (doc.errors.length > 0)
-        throw new RafError(`${file} : ${doc.errors[0].message}`);
-    const raw = doc.toJSON();
-    if (raw == null)
-        return {};
-    if (typeof raw !== 'object' || Array.isArray(raw))
-        throw new RafError(`${file} : la racine doit être un objet (lot → { date, reason })`);
-    const out = {};
-    for (const [id, v] of Object.entries(raw)) {
-        const e = v;
-        if (e && typeof e === 'object' && typeof e.reason === 'string' && e.reason.trim() !== '')
-            out[id] = { date: String(e.date ?? ''), reason: e.reason.trim() };
-    }
-    return out;
-}
 function foreignLots(raw, format) {
     const entries = raw.map((r, i) => {
         if (!r || typeof r !== 'object' || Array.isArray(r))
@@ -993,25 +1059,6 @@ function foreignLots(raw, format) {
     }
     return lots;
 }
-/** Lit `gate: { count: N, spec: true }` ou `{ count: N, screen: page }` ; toute autre forme est un problème du lot et une condition jamais remplie. */
-function readGate(raw, problems) {
-    if (raw == null)
-        return undefined;
-    const invalid = () => {
-        problems.push(GATE_INVALID);
-        return { invalid: true };
-    };
-    if (typeof raw !== 'object' || Array.isArray(raw))
-        return invalid();
-    const g = raw;
-    if (!Number.isInteger(g.count) || g.count < 1)
-        return invalid();
-    const criteria = [...(g.spec === true ? ['spec'] : []), ...(g.screen === 'page' ? ['screen'] : [])];
-    const others = Object.keys(g).filter((k) => k !== 'count' && k !== 'spec' && k !== 'screen');
-    if (criteria.length !== 1 || others.length || ('spec' in g && g.spec !== true) || ('screen' in g && g.screen !== 'page'))
-        return invalid();
-    return { count: g.count, criterion: criteria[0] };
-}
 /** Un titre public vide ne dirait rien au public : refusé plutôt qu'écrit. */
 function cleanPublic(text) {
     const t = text.trim();
@@ -1019,116 +1066,3 @@ function cleanPublic(text) {
         throw new RafError('titre public vide — raf public <id> "titre" (ou --clear pour l\'effacer)');
     return t;
 }
-function normalizeLot(raw, problems = []) {
-    const status = STATUSES.includes(raw.status) ? raw.status : 'todo';
-    const asDay = (field) => {
-        const v = raw[field];
-        if (v == null)
-            return undefined;
-        if (isDay(v))
-            return v;
-        problems.push(`${field} « ${String(v)} » n'est pas une date AAAA-MM-JJ`);
-        return undefined;
-    };
-    const after = raw.after == null ? [] : Array.isArray(raw.after) ? raw.after.map(String) : [String(raw.after)];
-    const last = asDay('last');
-    let uses;
-    if (raw.uses != null) {
-        if (Array.isArray(raw.uses) && raw.uses.every((n) => typeof n === 'string' && RESOURCE_NAME.test(n)))
-            uses = [...new Set(raw.uses)];
-        else
-            problems.push(`uses ${RESOURCES_BAD_LIST}`);
-    }
-    let screen;
-    if (raw.screen != null) {
-        if (SCREENS.includes(raw.screen))
-            screen = raw.screen;
-        else
-            problems.push(`screen « ${String(raw.screen)} » inconnu (${SCREENS.join(', ')})`);
-        if (screen && raw.visible !== true)
-            problems.push(`screen « ${screen} » sans visible : un écran est un changement visible`);
-    }
-    let spec;
-    if (raw.spec != null) {
-        if (raw.spec === true)
-            spec = true;
-        else if (raw.spec !== false)
-            problems.push(`spec : true ou false attendu (reçu « ${String(raw.spec)} »)`);
-    }
-    const gate = readGate(raw.gate, problems);
-    const okRaw = raw.docs_ok;
-    const docsOk = okRaw && typeof okRaw === 'object' && typeof okRaw.reason === 'string' && okRaw.reason.trim() !== '' ? { date: String(okRaw.date ?? ''), reason: okRaw.reason.trim() } : undefined;
-    return {
-        id: String(raw.id),
-        title: String(raw.title ?? ''),
-        status,
-        estimate: typeof raw.estimate === 'number' && raw.estimate > 0 ? raw.estimate : 1,
-        quickwin: raw.quickwin === true,
-        visible: raw.visible === true,
-        ...(screen ? { screen } : {}),
-        ...(spec ? { spec } : {}), ...(raw.local === true ? { local: true } : {}),
-        ...(gate ? { gate } : {}),
-        ...(typeof raw.public === 'string' && raw.public.trim() !== '' ? { public: raw.public.trim() } : {}),
-        ...(typeof raw.goal === 'string' && raw.goal.trim() !== '' ? { goal: raw.goal.trim() } : {}),
-        ...(Number.isInteger(raw.every) && raw.every > 0 ? { every: raw.every } : {}),
-        ...(last ? { last } : {}),
-        after,
-        ...(uses?.length ? { uses } : {}),
-        created: asDay('created'),
-        started: asDay('started'),
-        finished: asDay('finished'),
-        notes: Array.isArray(raw.notes)
-            ? raw.notes.map((n) => ({ date: String(n.date ?? ''), text: String(n.text ?? '') }))
-            : [],
-        tasks: Array.isArray(raw.tasks)
-            ? raw.tasks.map((t) => ({
-                id: String(t.id),
-                title: String(t.title ?? ''),
-                status: STATUSES.includes(t.status) ? t.status : 'todo',
-            }))
-            : [],
-        ...(repoList(raw.repos).length ? { repos: repoList(raw.repos) } : {}),
-        ...(asVerdict(raw.ux) ? { ux: asVerdict(raw.ux) } : {}),
-        ...(asVerdict(raw.review) ? { review: asVerdict(raw.review) } : {}),
-        ...(docsOk ? { docsOk } : {}),
-        problems,
-    };
-}
-/**
- * Dépôts voisins déclarés : une chaîne (le chemin) ou un objet `{ path, cite }`, seuls ou en liste (une valeur seule vaut une
- * liste d'un dépôt). Une entrée sans chemin textuel est écartée ; un `cite` vide ou non textuel vaut pas de `cite`.
- */
-function repoList(raw) {
-    const items = Array.isArray(raw) ? raw : raw == null ? [] : [raw];
-    const out = [];
-    for (const item of items) {
-        const path = typeof item === 'string' ? item : item && typeof item === 'object' && typeof item.path === 'string' ? item.path : '';
-        if (path.trim() === '')
-            continue;
-        const cite = item && typeof item === 'object' ? item.cite : undefined;
-        out.push({ path: path.trim(), ...(typeof cite === 'string' && cite.trim() !== '' ? { cite: cite.trim() } : {}) });
-    }
-    return out;
-}
-function asVerdict(raw) {
-    if (!raw || typeof raw !== 'object')
-        return undefined;
-    const v = raw;
-    // Écrit à la main sans verdict (clé absente, vide ou blanche) : rien n'a été dit de la revue, la porte
-    // reste fermée — comme `raf ux` et `raf review` refusent d'enregistrer un verdict vide.
-    if (String(v.verdict ?? '').trim() === '')
-        return undefined;
-    const verdict = { date: String(v.date ?? ''), verdict: String(v.verdict) };
-    // Champ présent mais vide : relu « jusqu'à rien », comme un verdict noté sans commit.
-    if ('commit' in v)
-        verdict.commit = v.commit == null || String(v.commit).trim() === '' ? null : String(v.commit).trim();
-    if (v.repos && typeof v.repos === 'object' && !Array.isArray(v.repos)) {
-        const repos = Object.entries(v.repos).map(([k, sha]) => [k, sha == null || String(sha).trim() === '' ? null : String(sha).trim()]);
-        if (repos.length)
-            verdict.repos = Object.fromEntries(repos);
-    }
-    const r = v.reporte;
-    if (r && typeof r === 'object' && !Array.isArray(r) && r.de != null && r.vers != null)
-        verdict.reporte = { de: String(r.de), vers: String(r.vers), patchId: String(r.patchId ?? '') };
-    return verdict;
-}

package/dist/raf-close-checks.js

@@ -0,0 +1,25 @@
+import { readOrchestrateConfig } from './config.js';
+import { gitRoot } from './git.js';
+import { redAcceptations } from './orchestrate/accept.js';
+import { RafError } from './plan.js';
+/**
+ * Un lot clos avec une acceptation à vert: false bloque les vagues suivantes du dépôt (verrou des tests d'acceptation, L366) :
+ * `raf done` le refuse, ou avec `--force` n'en fait qu'un avertissement sur `warn`.
+ */
+export function refuseRedAcceptation(root, configPath, lotId, force, warn) {
+    const repo = gitRoot(root) ?? root;
+    let dir = null;
+    try {
+        dir = readOrchestrateConfig(configPath).spec.dir;
+    }
+    catch {
+        // un cadence.yaml illisible ne doit pas empêcher de clore un lot : `cadence check` en parle
+    }
+    const red = dir === null ? undefined : redAcceptations(repo, dir).find((a) => a.lot === lotId);
+    if (!red)
+        return;
+    const text = `${lotId} : ${red.path} est à vert: false — clos ainsi, le lot bloquerait les vagues suivantes du dépôt (verrou des tests d'acceptation) ; cadence spec green ${lotId} lance la commande d'acceptation et pose vert: true`;
+    if (!force)
+        throw new RafError(`${text} (--force pour passer outre)`);
+    warn(`avertissement : ${text}`);
+}

package/dist/raf-status.js

@@ -0,0 +1,28 @@
+import { RafError } from './plan.js';
+import { currentState } from './plan-states.js';
+/** Une ligne par état déclaré : son statut de base, le nombre de lots qui y sont et, si `plan.transitions` est déclaré, les états permis ensuite. */
+function listStates(plan, out) {
+    const model = plan.stateModel;
+    if (!model)
+        throw new RafError('aucun état déclaré : cadence.yaml plan.states');
+    const lots = plan.lots();
+    for (const [name, base] of Object.entries(model.states)) {
+        const next = model.transitions ? `  → ${model.transitions[name]?.join(', ') || '(terminal)'}` : '';
+        out(`${name}  ${base}  ${lots.filter((l) => currentState(model, l) === name).length} lot(s)${next}`);
+    }
+}
+/** `raf status` (L463) : sans argument la liste des états ; `<id> <état> ["message"]` ou `<id> --back ["message"]` pose l'état d'un lot. */
+export function statusCommand(plan, rest, ctx) {
+    const { back, today, out } = ctx;
+    if (rest.length === 0 && !back) {
+        listStates(plan, out);
+        return 0;
+    }
+    const first = back ? 1 : 2;
+    if (rest.length < first)
+        throw new RafError('usage : raf status <id> <état> ["message"] | raf status <id> --back ["message"]');
+    const state = plan.setState(rest[0], back ? null : rest[1], today, { back, message: rest.slice(first).join(' ') }, () => ctx.commits(plan, rest[0]));
+    plan.save();
+    out(`${rest[0]} → ${state}`);
+    return 0;
+}

package/dist/state.js

@@ -203,6 +203,29 @@ export function appendFailedDelivery(dir, day, sha, reason, cls, tail = []) {
     const head = `${day} ${sha} ${cls ? `[${cls}] ` : ''}${clean(reason.split('\n')[0], REASON_MAX)}`;
     appendFileSync(join(dir, 'deliveries-failed.log'), `${[head, ...kept].join(TAIL_SEP)}\n`);
 }
+/**
+ * `cadence verify` vert au sha de la DERNIÈRE livraison rouge (L435) : l'effet est bien là, la livraison est donc
+ * faite — une ligne « jour sha » rejoint `deliveries.log`, ce qui efface la ligne rouge du panneau (le journal vert
+ * modifié après le rouge la remplace) sans relivrer. Rien n'est écrit quand la dernière livraison rouge est celle
+ * d'un autre sha (elle resterait cachée), quand elle n'est pas de classe « vérification » (une CI rouge, un refus ou
+ * un déploiement raté ne se lavent pas : les vérifications ne lisent pas toujours le sha), quand il n'y en a pas, ou quand le journal vert est déjà postérieur au
+ * rouge (les dates de modification des fichiers décident, comme au panneau). Retourne si une ligne a été écrite.
+ */
+export function recordVerifiedDelivery(dir, day, sha) {
+    const last = readFailedEntries(dir).at(-1);
+    if (!last || last.sha !== sha || last.cls !== 'verification')
+        return false;
+    try {
+        const green = join(dir, 'deliveries.log');
+        if (existsSync(green) && statSync(green).mtimeMs > statSync(join(dir, 'deliveries-failed.log')).mtimeMs)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    appendDelivery(dir, day, sha);
+    return true;
+}
 export function lastDelivery(dir) {
     const file = join(dir, 'deliveries.log');
     if (!existsSync(file))

package/dist/verify.js

@@ -1,9 +1,9 @@
 import { spawn } from 'node:child_process';
 import { constants } from 'node:os';
 import { headSha, repoStatus, upstreamHead, upstreamIsDefaultBranch } from './git.js';
-import { lastDelivery, sharedStateDir } from './state.js';
+import { lastDelivery, recordVerifiedDelivery, sharedStateDir } from './state.js';
 import { onTermination } from './proc.js';
-import { describeCheck, realDeps, retryCheck, TIMED_OUT } from './deliver.js';
+import { announceDelivered, describeCheck, realDeps, retryCheck, TIMED_OUT } from './deliver.js';
 function killGroup(pgid, sig) {
     try {
         process.kill(-pgid, sig);
@@ -115,7 +115,24 @@ export async function verifyCommand(ctx, deps) {
     for (const r of results)
         out(resultLine(r));
     out(summaryLine(results));
-    return results.some((r) => r.reason !== null) ? 1 : 0;
+    if (results.some((r) => r.reason !== null))
+        return 1;
+    if (ctx.journal) {
+        const prev = lastDelivery(ctx.journal.dir); // lu avant l'écriture : la livraison précédente, d'où partent les lots annoncés
+        if (recordVerifiedDelivery(ctx.journal.dir, ctx.journal.day, ctx.sha)) {
+            out(`verify : ${ctx.sha.slice(0, 7)} avait une livraison rouge, l'effet est vert — inscrit au journal des livraisons`);
+            let effects;
+            try {
+                effects = ctx.journal.effects();
+            }
+            catch (e) {
+                out(`verify : lots livrés non annoncés — ${e.message.split('\n')[0]}`);
+                return 0;
+            }
+            announceDelivered(effects, prev, ctx.sha);
+        }
+    }
+    return 0;
 }
 /**
  * Délai de chaque vérification de « session start », lancées en parallèle : c'est aussi, à la mise à mort

package/dist/yaml-keys.js

@@ -4,3 +4,5 @@ export function booleanKey(value, refusal) {
         throw refusal;
     return value;
 }
+export const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+export const list = (v) => (v == null ? [] : Array.isArray(v) ? v.map(String) : [String(v)]);

package/docs/deliver.md

@@ -234,8 +234,9 @@ about it anywhere, the script declares it in `CADENCE_DEPLOYED_FILE` (above). Ex
 ## verify: replay the effect checks, outside a delivery
 
 A green delivery says the effect was right *then*. `cadence verify` replays the
-`deliver.verify` checks of `cadence.yaml` at any time — no CI, no deploy, no lock,
-no journal entry, nothing written.
+`deliver.verify` checks of `cadence.yaml` at any time — no CI, no deploy, no lock.
+It writes nothing, with one exception (below): a green verify at the sha of the last
+red delivery.
 
 ```sh
 cadence verify                # one pass, one line per check, then a one-line summary
@@ -249,6 +250,27 @@ cadence verify --sha 6b0d9aa  # the sha that replaces ${SHA} / ${SHORT} (default
 verify : 1 effet rouge sur 2 vérifications
 ```
 
+**A green verify clears a red delivery of the same sha** (L435). When every check is
+green and the sha verified is the one of the *last* line of `deliveries-failed.log`
+(a `[verification]` delivery that failed on an outage, say, while the effect is there), `verify` appends
+`day sha` to `deliveries.log` and prints `verify : <sha> avait une livraison rouge,
+l'effet est vert — inscrit au journal des livraisons`; the `cadence-hud` panel, which
+shows the red line until `deliveries.log` is newer than `deliveries-failed.log`, drops
+it without delivering again. That line **is** a delivery: as after `cadence deliver`, the
+lots cited by the commits since the previous green delivery are announced (`livré : L… — raf
+done …`) and the « Article <project> à rafraîchir » lot is opened when one has a public title
+(`docs.articles`, L144) — the next delivery starts from this line, so the lots in between are
+said here or never. Nothing is written when a check is red, when the last red
+delivery is another sha's (writing would hide it), when it is not of class `[verification]`
+(a red `[ci]`, `[refus]` or `[deploiement]` stays: checks do not always read the sha, so a green
+verify proves nothing about a commit that was never built or deployed), when there is no red delivery, or when
+`deliveries.log` was already modified after `deliveries-failed.log`. `deliveries-failed.log`
+is never rewritten, so `cadence perf` still counts the red delivery and now also the green one.
+One limit: the red line keeps the sha the delivery *started* from, so the green line written by
+`verify` is that sha too, even when a green `deliver` would have written the sha its script
+declared (`CADENCE_DEPLOYED_FILE`) or the head it moved to — that sha is not kept anywhere once the
+delivery is red; deliver again when the journal must name it.
+
 Exit code: **0** every check green · **1** at least one red effect · **2** nothing
 to verify or invalid configuration.
 

package/docs/fonctionnement.md

@@ -31,8 +31,11 @@ A lot without commits yet whose title cites a finding (`constat`, `revue`, `revi
 to the lead; « partial » passes what exists to the implementation. Then:
 
 - `screen: page` only: **spec** (mockup and screen sheet), **mockup review** (`ux-reviewer`, two
-  passes at most), then **accept**. `screen: component` and `screen: journey` lots take the ordinary
-  path, unless their sheet already exists.
+  passes at most), then **accept**.
+- a visible lot above 0.1 day with `screen: component`, `screen: journey` or no `screen:` (L459): **light
+  mockup**, a `spec` session (current screen and target for the touched states) and the same mockup review,
+  no **accept**; the `ux` pass after the code checks conformity to the mockup. Other lots take the ordinary
+  path (`orchestrate.maquette: false` brings it back for these too).
 - `spec: true` (a lot with a behaviour to pin down and no screen): **back-end spec** (cases, rules,
   contracts), **sheet review** (`code-reviewer` in sheet mode, two passes at most), then **accept**.
   A mixed lot (a page whose sheet has a `sujet` block) gets both reviews and a single second spec pass.
@@ -88,12 +91,13 @@ The budget a wave gives a lot is derived from its estimate, measured on the runs
 | beyond | 570 k per day, 750 k at least |
 | `screen: page` | 1.3 M at least, or the ordinary budget + 450 k if that is more |
 | `spec: true` | ordinary budget + 450 k |
+| visible, above 0.1 day, `screen: component` or `journey` or none (light mockup, L459) | ordinary budget + 450 k |
 | fix pass and short review | 155 k reserved |
 | escalation (`orchestrate.escalation` declared, L349) | + 175 k reserved (estimate: one correction and one fresh review on the escalation model) |
 
-The final review is always played; the budget bounds the writing passes. A `screen: component` or
-`screen: journey` lot takes the ordinary budget, unless its sheet already exists: it then gets the
-`screen: page` budget.
+The final review is always played; the budget bounds the writing passes. A non-visible lot, or one of
+0.1 day or less, with `screen: component`, `screen: journey` or none takes the ordinary budget; a visible one
+above 0.1 day gets the light mockup budget of the table.
 
 ## Permanent rules
 

package/docs/lead.md

@@ -10,7 +10,7 @@ summaries, decides with the human, and leaves the work to fresh short sessions r
   <img alt="The lead workflow in three lanes (human, lead session, orchestrate program and agents), from the tour of the projects to the close of the session" src="lead-workflow-light.svg">
 </picture>
 
-Dashed boxes are conditional steps: the precheck runs only for a lot without a commit yet whose title cites a finding (`constat`, `revue`, `review`, `audit`) or another lot (unless `orchestrate.precheck: false`), and the spec, sheet review and accept steps run only for a `screen: page` lot or a `spec: true` lot. The skill itself is `skills/lead/SKILL.md`; this page is its
+Dashed boxes are conditional steps: the precheck runs only for a lot without a commit yet whose title cites a finding (`constat`, `revue`, `review`, `audit`) or another lot (unless `orchestrate.precheck: false`), and the spec steps depend on the lot: a `screen: page` lot or a `spec: true` lot plays the full chain (spec, sheet review or mockup review, accept); a visible lot above 0.1 day without `screen: page` plays spec then the light mockup review, with no accept unless it already has a sealed acceptation (L459). The skill itself is `skills/lead/SKILL.md`; this page is its
 picture, not its source.
 
 ## The steps
@@ -24,11 +24,13 @@ picture, not its source.
    For each lot the program runs, in fresh sessions and in this order: `precheck → spec → maquette →
    accept → implement → review → ux`. The **precheck** applies to a lot without a commit yet whose title cites a finding (`constat`, `revue`, `review`, `audit`) or another lot (unless
    `orchestrate.precheck: false`; L288). The spec steps exist only for a lot that declares
-   a `screen:` of `page` (a visible lot that creates or changes a whole screen; `screen: component` and `screen: journey`
-   lots take the ordinary path, straight to the implementation, unless they already have a sheet) or `spec: true` (a lot without a screen
+   a `screen:` of `page` (a visible lot that creates or changes a whole screen) or `spec: true` (a lot without a screen
    that still has a behaviour to pin down: `precheck → spec → fiche → accept → implement → review`);
-   spec, sheet review and accept apply to `screen: page` and to `spec: true` alike; the other lots go
-   straight from the precheck (when it applies) to the implementation:
+   spec, sheet review and accept apply to `screen: page` and to `spec: true` alike. A visible lot above
+   0.1 day with `screen: component`, `screen: journey` or no `screen:` (and no `spec: true`) plays the
+   **light mockup** instead (L459): `precheck → spec → maquette → implement → review → ux`, no accept, and
+   the `ux` pass checks conformity to the mockup. The other lots go straight from the precheck (when it
+   applies) to the implementation:
    - **spec**: the `spec-writer` agent draws a static mockup to the project's own style and writes the
      screen sheet (`fiche.yaml`: fields, states, numbered rules), rendered at 1440 and 390 px;
    - **fiche** (a lot with a back-end part: `spec: true`, or a screen lot whose sheet has a `sujet` block):