@sylad/cadence 1.39.0 → 1.41.0

package/dist/orchestrate/table.js

@@ -5,6 +5,7 @@ export { estimateLines, launchPrices } from './cout.js';
 import { gitRoot, isAncestor } from '../git.js';
 import { repoWork } from '../repos.js';
 import { quotaReset } from './result.js';
+import { proposalLine, touchedReader } from './deja-traitee.js';
 const k = (n) => `${Math.round(n / 1000)} k`;
 const m = (n) => `${(n / 1_000_000).toFixed(1).replace('.', ',')} M`;
 export const LABEL = {
@@ -83,6 +84,15 @@ function gitCommitsOf(l) {
         return [];
     }
 }
+/**
+ * Les commits que les étapes du lot ont notés (entrées `<sha> <sujet>`, du plus ancien au plus récent), à défaut ceux que git lui attribue :
+ * les sha de la revue (`proposalHeads`) et ceux-là sont du même état de la branche, alors que git, lu depuis le HEAD du dépôt, ne voit pas
+ * les commits d'un lot non intégré et ne retrouve, après l'intégration par rebase, que des commits réécrits.
+ */
+function reviewedCommitsOf(l) {
+    const noted = [...new Set(l.steps.flatMap((s) => s.commits ?? []).filter((c) => !c.startsWith('[')).map((c) => c.split(' ')[0]))];
+    return noted.length ? noted : gitCommitsOf(l);
+}
 const sameCommit = (a, b) => a.length >= 4 && b.length >= 4 && (a.startsWith(b) || b.startsWith(a));
 /**
  * Sha des commits du lot dans son dépôt : ceux que git attribue au lot (une session en échec, au rapport illisible ou coupée
@@ -206,7 +216,7 @@ function signalLines(l) {
     return out;
 }
 /** Le détail d'un lot (L441) : ce que le tableau compact de `--status` n'imprime pas et que `--status --detail <lot>` donne. */
-function detailLines(l) {
+function detailLines(l, touched) {
     const out = [];
     if (l.goal)
         out.push(`${l.project}:${l.lot} — objectif donné : ${l.goal}`);
@@ -228,7 +238,7 @@ function detailLines(l) {
     for (const h of l.hypotheses ?? [])
         out.push(`${l.project}:${l.lot} — hypothèse de la fiche : ${h}`);
     for (const p of l.proposals)
-        out.push(`${l.project}:${l.lot} — proposé : ${p}`);
+        out.push(`${l.project}:${l.lot} — proposé : ${proposalLine(l, p, touched)}`);
     if (l.uxVerdict && l.visible)
         out.push(`${l.project}:${l.lot} — verdict UX pour « raf ux » : ${l.uxVerdict}`);
     return out;
@@ -237,7 +247,7 @@ function detailLines(l) {
  * `--status --detail <lot>` (L441) : les lignes de détail d'un lot de la vague, lues dans l'état de la vague (le fichier de chaque lot).
  * `sel` : `projet:lot` ou le seul `lot` s'il est unique dans la vague. Lot inconnu ou ambigu : lève.
  */
-export function renderDetail(lots, sel) {
+export function renderDetail(lots, sel, deps = {}) {
     const hit = lots.filter((l) => `${l.project}:${l.lot}` === sel);
     const found = hit.length ? hit : sel.includes(':') ? [] : lots.filter((l) => l.lot === sel);
     if (found.length === 0)
@@ -245,9 +255,23 @@ export function renderDetail(lots, sel) {
     if (found.length > 1)
         throw new Error(`lot ambigu : ${sel} (${found.map((l) => `${l.project}:${l.lot}`).join(', ')}) : donner projet:lot`);
     const l = found[0];
-    const lines = detailLines(l);
+    const lines = detailLines(l, touchedReader(deps, reviewedCommitsOf));
     return lines.length ? lines : [`${l.project}:${l.lot} — aucun détail (ni objectif, capture, choix, proposition, ni verdict UX)`];
 }
+/** Les lignes de signal et de détail de chaque lot, ajoutées à `out` ; rend les lots qui ont un détail. Compact : les lignes de détail ne sont pas imprimées, seul leur nombre compte, et la marque L422 n'en change pas le nombre : aucune lecture git. */
+function perLotLines(lots, out, deps) {
+    const touched = deps.compact ? () => null : touchedReader(deps, reviewedCommitsOf);
+    const withDetail = [];
+    for (const l of lots) {
+        out.push(...signalLines(l));
+        const lines = detailLines(l, touched);
+        if (lines.length > 0)
+            withDetail.push(`${l.project}:${l.lot}`);
+        if (!deps.compact)
+            out.push(...lines);
+    }
+    return withDetail;
+}
 /** Le tableau de fin de vague (ou de `--status`), une ligne par lot puis le total et les questions. `compact` (L441, `--status`) : sans le détail des lots, une seule ligne renvoie à `--status --detail`. */
 export function renderTable(wave, lots, deps = {}) {
     const cost = costView(lots, deps.prices);
@@ -270,13 +294,7 @@ export function renderTable(wave, lots, deps = {}) {
     for (const d of deliverable(lots, deps.isAncestor ?? isAncestor, deps.lotCommits ?? gitCommitsOf)) {
         out.push(`${d.ready.project}:${d.ready.lot} — livrable jusqu'à ${d.sha} (dernier commit de ${d.ready.lot}, sous ${d.under.lot} ${d.under.status === 'handed-back' || d.under.status === 'failed' ? 'rendu' : LABEL[d.under.status]}) : git push origin ${d.sha}:main && cadence deliver --sha ${d.sha}`);
     }
-    for (const l of lots) {
-        out.push(...signalLines(l));
-        if (deps.compact)
-            continue;
-        out.push(...detailLines(l));
-    }
-    const withDetail = lots.filter((l) => detailLines(l).length > 0).map((l) => `${l.project}:${l.lot}`);
+    const withDetail = perLotLines(lots, out, deps);
     if (deps.compact && withDetail.length)
         out.push(`détail (objectif, captures, base de tests, choix, propositions, verdict UX) : cadence orchestrate --status --detail <projet:lot> — ${withDetail.join(', ')}`);
     return out;

package/dist/plan-extras.js

@@ -0,0 +1,118 @@
+import { FIELDS, RafError } from './plan.js';
+const EXTRA_KEYS = ['enum', 'default'];
+const EXTRA_NAME = /^[a-z][a-z0-9_]*$/;
+/** Les clés que raf lit ou écrit sur un lot : un champ d'extension ne peut pas en prendre le nom. */
+const LOT_KEYS = ['tasks', 'uses', 'local', 'ux', 'review', 'docs_ok', 'extras', 'problems', 'state', 'state_before'];
+const nonEmptyText = (v) => typeof v === 'string' && v.trim() !== '';
+/** Une déclaration `plan.extras.<nom>` lue, ou l'erreur (message sans préfixe) qui la refuse. */
+function readDecl(name, decl) {
+    if (decl == null)
+        return {};
+    if (typeof decl !== 'object' || Array.isArray(decl))
+        return `extras.${name} doit être un objet { enum, default }`;
+    const d = decl;
+    const unknown = Object.keys(d).find((k) => !EXTRA_KEYS.includes(k));
+    if (unknown)
+        return `extras.${name}.${unknown} inconnu (attendu : ${EXTRA_KEYS.join(', ')})`;
+    const out = {};
+    if (d.enum != null) {
+        if (!Array.isArray(d.enum) || d.enum.length === 0 || !d.enum.every(nonEmptyText))
+            return `extras.${name}.enum doit être une liste non vide de textes`;
+        if (new Set(d.enum).size !== d.enum.length)
+            return `extras.${name}.enum : une valeur est donnée deux fois`;
+        out.enum = d.enum;
+    }
+    if (d.default != null) {
+        if (!nonEmptyText(d.default))
+            return `extras.${name}.default doit être un texte non vide`;
+        if (out.enum && !out.enum.includes(d.default))
+            return `extras.${name}.default « ${d.default} » hors de enum (${out.enum.join(', ')})`;
+        out.default = d.default;
+    }
+    return out;
+}
+/**
+ * Clé `plan.extras` de cadence.yaml (L464) lue en `{ extras }` (`{}` quand la clé manque). Refuse, en nommant la clé : une forme fausse, un nom invalide ou pris
+ * par un champ de raf, un plan tenu par un autre outil (`foreign` : lecture seule, raf n'y écrit aucun champ).
+ */
+export function readExtras(v, foreign, bad) {
+    if (v == null)
+        return {};
+    if (foreign)
+        throw bad("extras ne s'applique pas à un plan tenu par un autre outil (lecture seule)");
+    if (typeof v !== 'object' || Array.isArray(v))
+        throw bad('extras doit être un objet { champ: { enum, default } }');
+    const extras = {};
+    for (const [name, raw] of Object.entries(v)) {
+        if (!EXTRA_NAME.test(name))
+            throw bad(`extras.${name} : nom invalide (minuscules, chiffres et _, commençant par une lettre)`);
+        if (FIELDS.includes(name) || LOT_KEYS.includes(name))
+            throw bad(`extras.${name} : c'est un champ de raf, pas un champ d'extension`);
+        const decl = readDecl(name, raw);
+        if (typeof decl === 'string')
+            throw bad(decl);
+        extras[name] = decl;
+    }
+    return { extras };
+}
+/** Ce qui cloche dans la valeur d'un champ d'extension, ou null : champ non déclaré, pas un texte non vide, hors de `enum`. */
+function valueProblem(decls, name, value) {
+    const decl = decls[name];
+    if (!decl) {
+        const names = Object.keys(decls);
+        return names.length === 0 ? `${name} : aucun champ d'extension déclaré (cadence.yaml : plan.extras)` : `${name} : champ d'extension non déclaré (${names.join(', ')})`;
+    }
+    if (!nonEmptyText(value))
+        return `${name} : texte non vide attendu`;
+    if (decl.enum && !decl.enum.includes(value.trim()))
+        return `${name} « ${value.trim()} » hors de enum (${decl.enum.join(', ')})`;
+    return null;
+}
+/** Les champs à poser à la création d'un lot (`raf add --set`), validés et nettoyés ; une erreur refuse tout. Sans valeur donnée : rien. */
+export function checkedExtras(decls, given) {
+    const out = {};
+    for (const [name, value] of Object.entries(given ?? {})) {
+        const problem = valueProblem(decls ?? {}, name, value);
+        if (problem)
+            throw new RafError(problem);
+        out[name] = value.trim();
+    }
+    return out;
+}
+/**
+ * Le lot lu avec ses champs d'extension : la valeur écrite, sinon le `default`. Une valeur fausse est remontée par check (`bad-field`) et n'est pas gardée.
+ * Les clés non déclarées ne sont pas lues : elles restent sur le disque, intactes.
+ */
+export function withExtras(lot, raw, decls) {
+    const extras = {};
+    for (const [name, decl] of Object.entries(decls ?? {})) {
+        const written = raw[name];
+        if (written == null) {
+            if (decl.default !== undefined)
+                extras[name] = decl.default;
+            continue;
+        }
+        const problem = valueProblem(decls ?? {}, name, written);
+        if (problem)
+            lot.problems.push(problem);
+        else
+            extras[name] = written.trim();
+    }
+    return Object.keys(extras).length > 0 ? { ...lot, extras } : lot;
+}
+/** Les `--set champ=valeur` de `raf add` : champ → valeur, coupée au premier « = ». Une forme sans champ ou sans valeur, un champ donné deux fois : refusés. Rend undefined sans `--set`. */
+export function parseSet(sets) {
+    if (sets === undefined)
+        return undefined;
+    const out = {};
+    for (const item of sets) {
+        const [name, ...rest] = item.split('=');
+        const value = rest.join('=').trim();
+        if (name.trim() === '' || value === '')
+            throw new RafError(`--set attend champ=valeur (reçu « ${item} »)`);
+        if (Object.hasOwn(out, name.trim()))
+            throw new RafError(`--set ${name.trim()} est donné deux fois`);
+        out[name.trim()] = value;
+    }
+    return out;
+}

package/dist/plan-read.js

@@ -0,0 +1,144 @@
+import { isDay } from './dates.js';
+import { RESOURCE_NAME, RESOURCES_BAD_LIST, SCREENS, STATUSES } from './plan.js';
+const GATE_INVALID = 'gate invalide : count: entier ≥ 1 et un critère spec: true ou screen: page attendus';
+/** 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] };
+}
+/** `state:` et `state_before:` écrits à la main avec un non-texte : signalés, la clé étant écartée. */
+function checkStateNames(raw, problems) {
+    for (const k of ['state', 'state_before'])
+        if (raw[k] != null && typeof raw[k] !== 'string')
+            problems.push(`${k} : un nom d'état attendu (reçu « ${String(raw[k])} »)`);
+}
+export 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)} »)`);
+    }
+    checkStateNames(raw, problems);
+    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,
+        ...(typeof raw.state === 'string' && raw.state.trim() !== '' ? { state: raw.state.trim() } : {}),
+        ...(typeof raw.state_before === 'string' && raw.state_before.trim() !== '' ? { stateBefore: raw.state_before.trim() } : {}),
+        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/plan-states.js

@@ -0,0 +1,119 @@
+import { isObject, list } from './yaml-keys.js';
+import { STATUSES } from './plan.js';
+function parseBases(raw, bad) {
+    if (!isObject(raw))
+        throw bad('states doit être un objet { état: statut de base }');
+    const states = {};
+    for (const [name, base] of Object.entries(raw)) {
+        if (!STATUSES.includes(base))
+            throw bad(`states.${name} : statut de base « ${String(base)} » inconnu (attendu : ${STATUSES.join(', ')})`);
+        states[name] = base;
+    }
+    const bases = Object.values(states);
+    if (!['todo', 'doing', 'done'].every((b) => bases.includes(b)))
+        throw bad('states doit déclarer au moins un état todo, un doing et un done');
+    return states;
+}
+function parseTransitions(raw, states, bad) {
+    if (!isObject(raw))
+        throw bad('transitions doit être un objet { état: [états permis] }');
+    const transitions = {};
+    for (const [from, tos] of Object.entries(raw)) {
+        if (!Object.hasOwn(states, from))
+            throw bad(`transitions : « ${from} » n'est pas un état déclaré`);
+        for (const to of list(tos))
+            if (!Object.hasOwn(states, to))
+                throw bad(`transitions.${from} : « ${to} » n'est pas un état déclaré`);
+        transitions[from] = list(tos);
+    }
+    return transitions;
+}
+function requireNames(p, bad) {
+    for (const k of ['doneState', 'blockedState'])
+        if (p[k] != null && typeof p[k] !== 'string')
+            throw bad(`${k} : un nom d'état attendu`);
+}
+/**
+ * Lit `plan.states`, `plan.transitions`, `plan.doneState` et `plan.blockedState` de cadence.yaml : `{ states }` ou `{}` quand rien n'est déclaré.
+ * `foreign` : le plan est tenu par un autre outil (lots, fields, statuses, estimates), dont les états sont les siens.
+ */
+export function parseStates(p, bad, foreign) {
+    if (p.states == null) {
+        for (const k of ['transitions', 'doneState', 'blockedState'])
+            if (p[k] != null)
+                throw bad(`${k} demande plan.states`);
+        return {};
+    }
+    if (foreign)
+        throw bad('states ne va pas avec un plan tenu par un autre outil (lots, fields, statuses, estimates) : ses états sont les siens');
+    const states = parseBases(p.states, bad);
+    const model = { states };
+    if (p.transitions != null)
+        model.transitions = parseTransitions(p.transitions, states, bad);
+    requireNames(p, bad);
+    if (p.doneState != null) {
+        if (states[String(p.doneState)] !== 'done')
+            throw bad(`doneState : « ${String(p.doneState)} » n'est pas un état done`);
+        model.done = String(p.doneState);
+    }
+    if (p.blockedState != null) {
+        const base = states[String(p.blockedState)];
+        if (base !== 'todo' && base !== 'doing')
+            throw bad(`blockedState : « ${String(p.blockedState)} » doit être un état todo ou doing`);
+        model.blocked = String(p.blockedState);
+    }
+    return { states: model };
+}
+/** L'état que prend un lot qui entre dans ce statut de base : `doneState` pour done, sinon le premier état déclaré de ce statut. */
+export function defaultState(model, base) {
+    if (base === 'done' && model.done)
+        return model.done;
+    return Object.keys(model.states).find((s) => model.states[s] === base);
+}
+/** L'état d'un lot : celui qu'il porte, sinon l'état par défaut de son statut (lot écrit avant la déclaration). */
+export function currentState(model, lot) {
+    return lot.state ?? defaultState(model, lot.status) ?? lot.status;
+}
+/** Pourquoi `from → to` est refusé par `plan.transitions` ; `null` quand c'est permis ou que rien n'est déclaré. */
+export function transitionProblem(model, from, to) {
+    if (!model.transitions)
+        return null;
+    const allowed = model.transitions[from];
+    if (allowed?.includes(to))
+        return null;
+    return `${from} → ${to} n'est pas permis (${allowed?.length ? `depuis ${from} : ${allowed.join(', ')}` : 'état terminal'})`;
+}
+/** Les écarts d'un état écrit à la main : état non déclaré, ou statut de base qui contredit `status:`. */
+export function stateProblems(model, lot) {
+    if (lot.state === undefined)
+        return [];
+    const base = Object.hasOwn(model.states, lot.state) ? model.states[lot.state] : undefined;
+    if (base === undefined)
+        return [`état « ${lot.state} » non déclaré (cadence.yaml : plan.states)`];
+    return base === lot.status ? [] : [`état « ${lot.state} » (${base}) contredit status: ${lot.status}`];
+}
+/**
+ * Applique à `node` le changement de statut de base de `raf status` : todo → doing démarre le lot, doing → todo le remet en attente
+ * (`started:` retiré) — refusé, comme `raf todo`, dès qu'un commit cite le lot : le remettre en attente perdrait leur lien. Rend le refus
+ * (`move` nomme le lot, l'état visé et son statut de base), `undefined` quand le changement est fait. Autre changement : rien n'est touché,
+ * le refus renvoie à sa commande.
+ */
+export function rebase(node, lot, move, today, commits) {
+    const { ref, to, base } = move;
+    if (lot.status === 'todo' && base === 'doing') {
+        node.set('status', 'doing');
+        if (!lot.started)
+            node.set('started', today);
+        return undefined;
+    }
+    if (lot.status === 'doing' && base === 'todo') {
+        const n = commits();
+        if (n > 0)
+            return `${ref} a ${n} commit(s) qui le citent : le remettre en attente perdrait leur lien — un état doing (raf status ${ref} <état>), ou raf drop ${ref}`;
+        node.set('status', 'todo');
+        node.delete('started');
+        return undefined;
+    }
+    const command = base === 'done' ? 'done' : base === 'dropped' ? 'drop' : 'todo';
+    return `${ref} : ${to} a pour statut de base ${base}, ${lot.status} aujourd'hui — passer par raf ${command} ${ref}`;
+}