@sylad/cadence 1.1.0 → 1.3.0

package/dist/orchestrate/launch.js

@@ -8,12 +8,12 @@ import { sandboxEnv } from './sandbox.js';
 import { killMarked, SESSION_MARK_VAR, TreeTracker } from '../proc.js';
 import { isQuotaMessage, lacksStructuredOutput, parseSession, salvageUsage, sumTokens, tokensOf } from './result.js';
 /**
- * Serveurs MCP d'une étape : Playwright pour `ux` et `maquette` (revue des captures et du HTML local, L172) et, sur un lot `visible`, pour `spec` (rendu 1440/390 de la maquette, L171), `implement` et `fix` (fix-minors compris) ;
+ * Serveurs MCP d'une étape : Playwright pour `ux` et `maquette` (revue des captures et du HTML local, L172) et, sur un lot `visible`, pour `spec` quand il a un écran `screen:` (rendu 1440/390 de la maquette, L171), `implement` et `fix` (fix-minors compris) ;
  * et `review-small` d'un petit lot visible (sa seule revue d'ergonomie) ; rien pour `review`, ni pour un lot sans écran.
  * Sorties dans `outputDir`, hors du dépôt.
  */
-export function mcpServersFor(kind, visible, outputDir, small = false) {
-    if (!(kind === 'ux' || kind === 'maquette' || (visible && (kind === 'spec' || kind === 'implement' || kind === 'fix' || (kind === 'review-small' && small)))))
+export function mcpServersFor(kind, visible, outputDir, small = false, screen = true) {
+    if (!(kind === 'ux' || kind === 'maquette' || (visible && ((kind === 'spec' && screen) || kind === 'implement' || kind === 'fix' || (kind === 'review-small' && small)))))
         return {};
     // La maquette est un fichier local : sans cette option le serveur bloque toute URL file:// (« Access to "file:" protocol is blocked »).
     const files = kind === 'maquette' || kind === 'spec' ? ['--allow-unrestricted-file-access'] : [];
@@ -24,18 +24,18 @@ export function playwrightDir(lotDir) {
     return join(resolve(lotDir), 'playwright');
 }
 /** Écrit `<lotDir>/mcp-<étape>.json` (et, si Playwright est chargé, le dossier `playwright/`) ; rend le chemin absolu du fichier. */
-export function writeMcpConfig(lotDir, kind, visible, small = false) {
+export function writeMcpConfig(lotDir, kind, visible, small = false, screen = true) {
     const dir = resolve(lotDir);
     const out = playwrightDir(dir);
-    const servers = mcpServersFor(kind, visible, out, small);
+    const servers = mcpServersFor(kind, visible, out, small, screen);
     if (servers.playwright)
         mkdirSync(out, { recursive: true });
     const file = join(dir, `mcp-${kind}.json`);
     writeFileSync(file, `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`);
     return file;
 }
-/** Outils interdits à toute session : pas de sous-agent, pas de push, de livraison ni de verdict. */
-export const DISALLOWED = ['Agent', 'Bash(git push:*)', 'Bash(cadence deliver:*)', 'Bash(raf done:*)', 'Bash(raf review:*)', 'Bash(raf ux:*)'];
+/** Outils interdits à toute session : pas de sous-agent, pas de push, de livraison, de verdict ni de rescellé d'un test d'acceptation (le chemin du lead, L200). */
+export const DISALLOWED = ['Agent', 'Bash(git push:*)', 'Bash(cadence deliver:*)', 'Bash(raf done:*)', 'Bash(raf review:*)', 'Bash(raf ux:*)', 'Bash(cadence spec reseal:*)', 'Bash(raf spec reseal:*)'];
 /** Outils MCP du serveur Playwright, par le préfixe du serveur (sonde réelle du 07-10 : `mcp__playwright` expose tous les `browser_*`). */
 export const PLAYWRIGHT_TOOLS = 'mcp__playwright';
 /** Agents passés à `--agents` : l'agent d'une étape qui charge Playwright, s'il a une liste d'outils, y gagne les outils du serveur (sinon il ne peut pas l'appeler). */
@@ -129,7 +129,7 @@ export function buildRetryArgs(spec, sessionId, agents) {
  */
 export async function runSession(spec, deps) {
     const sandbox = sandboxEnv(!!spec.prodAccess);
-    const launch = (args) => deps.claude(args, { local: spec.local, cwd: spec.cwd, unset: sandbox.unset, env: { CADENCE_ORCHESTRATED: spec.wave, ...sandbox.set, ...(spec.nodeBin || spec.toolBin ? { PATH: [spec.toolBin, spec.nodeBin, process.env.PATH ?? ''].filter(Boolean).join(delimiter) } : {}) }, timeoutMs: spec.timeoutMs, onSpawn: deps.onSpawn });
+    const launch = (args) => deps.claude(args, { local: spec.local, cwd: spec.cwd, unset: sandbox.unset, env: { CADENCE_ORCHESTRATED: spec.wave, ...sandbox.set, ...(spec.nodeBin || spec.toolBin ? { PATH: [spec.toolBin, spec.nodeBin, process.env.PATH ?? ''].filter(Boolean).join(delimiter) } : {}) }, timeoutMs: spec.timeoutMs, onSpawn: deps.onSpawn, lot: spec.lot });
     const out = await launch(spec.local ? buildLocalArgs(spec, deps.agents) : buildArgs(spec, deps.agents));
     const first = classify(out);
     if (spec.local)

package/dist/orchestrate/spec.js

@@ -2,14 +2,28 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { parse } from 'yaml';
+import { acceptationFile } from './accept.js';
 import { checkFiche, fichesDuDossier, LARGEURS } from '../spec.js';
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 const list = (v) => (Array.isArray(v) ? v.filter(isObj) : []);
-/** Chemin (relatif au dépôt) de la fiche du lot sous `<dir>/<écran>/fiche.yaml`, ou null : sert à ne pas rejouer une spec déjà écrite. */
+/** Chemin (relatif au dépôt) de la fiche du lot sous `<dir>/<écran ou sujet>/fiche.yaml` (`ecran.lot` ou `sujet.lot`), ou null : sert à ne pas rejouer une spec déjà écrite. */
 export function findFiche(repo, dir, lot) {
-    const hit = fichesDuDossier(repo, dir).find(({ doc }) => isObj(doc.ecran) && doc.ecran.lot === lot);
+    const hit = fichesDuDossier(repo, dir).find(({ doc }) => (isObj(doc.ecran) && doc.ecran.lot === lot) || (isObj(doc.sujet) && doc.sujet.lot === lot));
     return hit ? `${dir}/${hit.name}/fiche.yaml` : null;
 }
+/**
+ * L'écran qui fait entrer un lot dans la chaîne spec → maquette → accept (L209) : `page` seul. `component` et `journey` restent des valeurs
+ * valides du plan mais le lot suit le chemin ordinaire, sauf s'il est déjà entré dans la chaîne (une fiche à bloc `ecran` du lot, ou son
+ * `acceptation-<lot>.json` à côté d'une fiche à bloc `ecran`, existent dans `dir`) : il garde alors sa fiche et son verrou.
+ */
+export function specScreen(repo, dir, lot) {
+    if (!lot.screen || lot.screen === 'page')
+        return lot.screen;
+    // Seul un bloc `ecran` compte : la fiche back (bloc `sujet`) et son acceptation sont ce qu'écrit la spec d'un lot `spec: true`.
+    const acceptation = acceptationFile('fiche.yaml', lot.id);
+    const entered = fichesDuDossier(repo, dir).some(({ name, doc }) => isObj(doc.ecran) && (doc.ecran.lot === lot.id || existsSync(join(repo, dir, name, acceptation))));
+    return entered ? lot.screen : undefined;
+}
 /** Texte sans accents ni majuscules, pour les mots-clés. */
 const plain = (s) => s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
 /**
@@ -40,9 +54,19 @@ export function costlyHypotheses(doc) {
     }
     return out;
 }
+/** La fiche écrite porte une partie back (un bloc `sujet`) : c'est ce qui fait d'un lot à `screen:` un lot mixte (L188), jamais un champ `spec: true` à côté de `screen:`. */
+export function ficheHasBack(repo, fiche) {
+    try {
+        const doc = parse(readFileSync(join(repo, fiche), 'utf8'));
+        return isObj(doc) && 'sujet' in doc;
+    }
+    catch {
+        return false;
+    }
+}
 /** Une fiche déjà écrite ne dispense de la spec que si elle passe les contrôles du programme et ne porte aucune hypothèse coûteuse. */
-export function ficheReady(repo, fiche, lot) {
-    if (checkSpec(repo, fiche, lot).length)
+export function ficheReady(repo, fiche, lot, parts = { screen: true, back: false }) {
+    if (checkSpec(repo, fiche, lot, parts).length)
         return false;
     try {
         return costlyHypotheses(parse(readFileSync(join(repo, fiche), 'utf8'))).length === 0;
@@ -74,10 +98,10 @@ function tracked(repo, dir) {
  * elle est celle du lot et de son dossier, la maquette existe avec une section `#etat-<état>` par état et un
  * `data-testid` par champ, et chaque état a sa capture à chaque largeur — le tout commité.
  */
-export function checkSpec(repo, fiche, lot) {
+export function checkSpec(repo, fiche, lot, parts = { screen: true, back: false }) {
     const file = join(repo, fiche);
     if (!existsSync(file))
-        return [`${fiche} : fiche absente (écrire docs/specs/<écran>/fiche.yaml et la commiter)`];
+        return [`${fiche} : fiche absente (écrire ${fiche.replace(/[^/]+\/fiche\.yaml$/, parts.screen ? '<écran>' : '<sujet>')}/fiche.yaml et la commiter)`];
     let doc;
     try {
         doc = parse(readFileSync(file, 'utf8'));
@@ -86,9 +110,30 @@ export function checkSpec(repo, fiche, lot) {
         return [`${fiche} : YAML illisible (${e.message.split('\n')[0]})`];
     }
     const problems = checkFiche(doc).map((p) => `fiche : ${p}`);
-    if (!isObj(doc) || !isObj(doc.ecran))
+    if (!isObj(doc))
         return problems;
     const folder = fiche.replace(/\/fiche\.yaml$/, '');
+    // un lot back (`spec: true`, avec ou sans écran) écrit la partie sujet : sans elle, ni lot ni dossier ne seraient contrôlés
+    if (parts.back) {
+        if (!isObj(doc.sujet)) {
+            if (!('sujet' in doc) && 'ecran' in doc)
+                problems.push('fiche : sujet : bloc manquant (un lot qui change un comportement écrit la partie sujet, même si la fiche a aussi un écran)');
+        }
+        else {
+            const sujet = doc.sujet;
+            if (typeof sujet.lot === 'string' && sujet.lot !== lot)
+                problems.push(`sujet.lot : « ${sujet.lot} » au lieu de ${lot} (la fiche est celle du lot qui implémente le comportement)`);
+            if (typeof sujet.id === 'string' && !folder.endsWith(`/${sujet.id}`))
+                problems.push(`sujet.id : « ${sujet.id} » ne correspond pas au dossier ${folder}`);
+            if (!parts.screen && !tracked(repo, folder).has(fiche))
+                problems.push(`${fiche} : fiche non commité`);
+        }
+    }
+    if (!parts.screen)
+        return problems;
+    // un lot à écran écrit la partie écran : sans elle, ni lot, ni dossier, ni maquette, ni captures ne seraient contrôlés
+    if (!isObj(doc.ecran))
+        return [...problems.filter((p) => p !== 'fiche : ecran : bloc manquant'), 'fiche : ecran : bloc manquant (un lot à écran écrit la partie écran, même si la fiche a aussi un sujet)'];
     const ecran = doc.ecran;
     if (typeof ecran.lot === 'string' && ecran.lot !== lot)
         problems.push(`ecran.lot : « ${ecran.lot} » au lieu de ${lot} (la fiche est celle du lot qui implémente l'écran)`);
@@ -121,17 +166,43 @@ export function checkSpec(repo, fiche, lot) {
             need(`${folder}/maquette-${e}-${w}.png`, 'capture');
     return problems;
 }
+/** Première phrase d'un texte, ramenée à une longueur lisible dans une note. */
+const sentence = (t, max = 160) => {
+    const flat = t.replace(/\s+/g, ' ').trim();
+    const end = flat.search(/[.!?](\s|$)/);
+    const first = end > 0 ? flat.slice(0, end) : flat;
+    return first.length > max ? `${first.slice(0, max - 1).trimEnd()}…` : first;
+};
+/** Une ligne par règle `hypothese` de la fiche (`R3 : ce que la règle dit ; si faux : ce qui changerait`), pour la note du lot et le tableau de fin de vague (spec etape-spec-back § 7). */
+export function hypothesisLines(doc) {
+    if (!isObj(doc))
+        return [];
+    return list(doc.regles)
+        .filter((r) => r.statut === 'hypothese' && typeof r.id === 'string')
+        .map((r) => `${String(r.id)} : ${sentence(String(r.enonce ?? ''))} ; si faux : ${sentence(String(r.si_faux ?? ''))}`);
+}
+/** Texte de la note du lot pour une hypothèse (une note par règle). */
+export const hypothesisNote = (sujet, line) => `Hypothèses (fiche ${sujet}) — ${line}`;
 /** Consigne propre à l'étape spec dans le brief : dossier, largeurs, commande de rendu, et les écarts de la passe précédente. */
 export function specText(o) {
-    const lines = [
-        `The lot declares \`screen: ${o.screen ?? 'page'}\`. The specs of this project live in \`${o.dir}/<écran>/\` (one folder per screen, \`<écran>\` = the kebab-case \`ecran.id\` of the sheet).`,
-        `Render each state of the mockup at ${LARGEURS.map((w) => `${w}`).join(' and ')} px width: one capture per state and per width, named \`maquette-<état>-<largeur>.png\` (e.g. \`maquette-vide-1440.png\`).`,
-        o.render
+    const lines = [];
+    if (o.screen) {
+        lines.push(`The lot declares \`screen: ${o.screen}\`. The specs of this project live in \`${o.dir}/<écran>/\` (one folder per screen, \`<écran>\` = the kebab-case \`ecran.id\` of the sheet).`, `Render each state of the mockup at ${LARGEURS.map((w) => `${w}`).join(' and ')} px width: one capture per state and per width, named \`maquette-<état>-<largeur>.png\` (e.g. \`maquette-vide-1440.png\`).`, o.render
             ? `The project declares how to render mockups (\`orchestrate.spec.render\`): \`${o.render}\` (from the repository root). Use it; fall back on Playwright only if it cannot run, and say so under "nonVerifie".`
-            : 'No render command is declared (`orchestrate.spec.render`): render with Playwright (open `maquette.html` as a local file, resize to each width, open each `#etat-<état>`).',
-    ];
+            : 'No render command is declared (`orchestrate.spec.render`): render with Playwright (open `maquette.html` as a local file, resize to each width, open each `#etat-<état>`).');
+    }
+    if (o.back) {
+        lines.push(o.screen
+            ? `The sheet has both parts, \`sujet\`, \`cas\`, \`contrats\`, \`donnees\` next to \`ecran\`, in the same folder (\`sujet.id\` = \`ecran.id\` = the folder name, \`sujet.lot\` = \`ecran.lot\`); the API calls of the screen are listed once in \`contrats\`, and the actions point to them with \`contrat: Ax\`.`
+            : `The lot declares \`spec: true\` (it changes a behaviour, with no screen). The specs of this project live in \`${o.dir}/<sujet>/\` (one folder per subject, \`<sujet>\` = the kebab-case \`sujet.id\` of the sheet); the sheet has no screen part.`);
+    }
+    if (o.screen && !o.back) {
+        lines.push(`If the lot also changes a behaviour (an API call, a stored datum, a contract), add the back part to the same sheet: \`sujet\`, \`cas\`, \`contrats\`, \`donnees\` next to \`ecran\` (\`sujet.id\` = \`ecran.id\` = the folder name, \`sujet.lot\` = \`ecran.lot\`); the program then also has the sheet reviewed (rules sourced, contradictions, errors and limits, one test per rule), before the mockup. A lot that only draws a screen keeps a sheet without \`sujet\`.`);
+    }
     if (o.template)
-        lines.push('', 'Template of the sheet (`templates/fiche.yaml` of cadence; every key and invariant is checked by `cadence spec check`):', '```yaml', o.template.trimEnd(), '```');
+        lines.push('', 'Template of the screen part of the sheet (`templates/fiche.yaml` of cadence; every key and invariant is checked by `cadence spec check`):', '```yaml', o.template.trimEnd(), '```');
+    if (o.templateBack)
+        lines.push('', 'Template of the back part of the sheet (`templates/fiche-back.yaml` of cadence; every key and invariant is checked by `cadence spec check`):', '```yaml', o.templateBack.trimEnd(), '```');
     if (o.problems?.length)
         lines.push('', 'The program checked your previous spec and it did not pass; fix exactly these points (one more pass only, then the lot goes back to the lead):', ...o.problems.map((p) => `- ${p}`));
     if (o.review)

package/dist/orchestrate/state.js

@@ -11,8 +11,8 @@ export const lotRepoPaths = (l) => [l.repo, ...(l.repos ?? []).map((r) => r.path
 /** Les dépôts voisins du lot, donnés en `--add-dir` à ses sessions. */
 export const neighbourDirs = (l) => (l.repos ?? []).map((r) => r.path);
 export const lotKey = (project, lot) => `${project}:${lot}`;
-/** Nom de dossier d'un lot dans la vague : le « / » d'un id de sous-tâche (`Q4/accueil-4-ux12`) devient « __ » ; un id sans « / » est inchangé. */
-export const lotSlug = (project, lot) => `${project}--${lot.split('/').join('__')}`;
+/** Nom de dossier d'un lot dans la vague : le « / » d'un id de sous-tâche (`Q4/accueil-4-ux12`) ou d'un projet imbriqué (`groupe/gamma`) devient « __ » ; sans « / » le nom est inchangé. */
+export const lotSlug = (project, lot) => `${project.split('/').join('__')}--${lot.split('/').join('__')}`;
 const lotFile = (project, lot) => `${lotSlug(project, lot)}.json`;
 function atomicWrite(file, data) {
     const tmp = `${file}.${process.pid}.tmp`;

package/dist/orchestrate/table.js

@@ -123,6 +123,8 @@ export function renderTable(wave, lots, deps = {}) {
             out.push(`${l.project}:${l.lot} — ⚠ ${w}`);
         for (const x of l.choix ?? [])
             out.push(`${l.project}:${l.lot} — choix fait : ${x}`);
+        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}`);
         if (l.uxVerdict && l.visible)

package/dist/orchestrate/waits.js

@@ -0,0 +1,120 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isDay, toDay } from '../dates.js';
+import { RunStore } from './state.js';
+/** « 4 min 27 s », « 45 s », « 1 h 02 min 03 s » (la forme de `duration` et des lignes du journal) en millisecondes ; null si illisible. */
+export function parseWaitMs(text) {
+    const m = /^(?:(\d+) h )?(?:(\d+) min )?(\d+) s$/.exec(text.trim());
+    if (!m)
+        return null;
+    return ((Number(m[1] ?? 0) * 60 + Number(m[2] ?? 0)) * 60 + Number(m[3])) * 1000;
+}
+/**
+ * Les attentes d'un créneau d'un journal : comptées à l'obtention (« obtenu après … »), au jour de cette ligne ; `unfinished` = attentes commencées sans créneau obtenu.
+ * Chaque attente est appariée à son lot (« <projet>:<lot> · … ») : deux lots d'une même vague (un par dépôt, runPool) attendent en même temps. Une ligne sans lot (journal d'avant) est celle de la vague entière.
+ */
+export function parseWaits(journal) {
+    const waits = [];
+    let unfinished = 0;
+    const state = new Map(); // « depuis » de la dernière ligne d'attente : une ligne dont il ne progresse pas (recule, ou « depuis 0 s » de nouveau) est celle d'une nouvelle attente
+    for (const line of journal.split('\n')) {
+        const m = /^(\S+) (?:(\S+) · )?(?:en attente d'un créneau de session depuis (.+?) \(|créneau de session obtenu après (.+?) d'attente)/.exec(line);
+        if (!m)
+            continue;
+        const key = m[2] ?? '';
+        let s = state.get(key);
+        if (!s)
+            state.set(key, (s = { open: false, since: 0 }));
+        if (m[4] === undefined) {
+            const ms = parseWaitMs(m[3]) ?? 0;
+            if (s.open && ms <= s.since)
+                unfinished++;
+            s.open = true;
+            s.since = ms;
+            continue;
+        }
+        const ms = parseWaitMs(m[4]);
+        const at = new Date(m[1]);
+        if (ms !== null && !Number.isNaN(at.getTime()))
+            waits.push({ day: toDay(at), ms });
+        s.open = false;
+    }
+    for (const s of state.values())
+        if (s.open)
+            unfinished++;
+    return { waits, unfinished };
+}
+/** Les arrêts par le quota d'un journal (« … → suspended — quota atteint », cycle.ts), au jour de la ligne : le statut final de wave.json ne les garde pas, `--resume` le remet à `running` puis `done`. */
+export function parseQuotaStops(journal) {
+    const days = [];
+    for (const line of journal.split('\n')) {
+        const m = /^(\S+) \S+ → suspended — quota atteint$/.exec(line);
+        const at = m ? new Date(m[1]) : null;
+        if (at && !Number.isNaN(at.getTime()))
+            days.push(toDay(at));
+    }
+    return days;
+}
+/** Attente de créneau par vague et par jour, lue dans les `journal.log` et `wave.json` de `.cadence/runs/<vague>/` du dossier de lancement ; `since` écarte les vagues d'avant ce jour (début de l'identifiant). */
+export function readWaits(launchDir, since) {
+    const base = RunStore.runsDir(launchDir);
+    const ids = existsSync(base) ? readdirSync(base).filter((n) => existsSync(join(base, n, 'wave.json'))).sort() : [];
+    const waves = [];
+    const days = new Map();
+    const dayOf = (day) => {
+        let d = days.get(day);
+        if (!d)
+            days.set(day, (d = { day, totalMs: 0, count: 0, waves: 0, quotaHits: 0, consumed: 0 }));
+        return d;
+    };
+    for (const id of ids) {
+        const idDay = id.slice(0, 10);
+        if (!isDay(idDay) || (since && idDay < since))
+            continue; // un dossier qui n'est pas une vague datée (essai à la main) n'a pas de jour
+        let meta = {};
+        try {
+            meta = JSON.parse(readFileSync(join(base, id, 'wave.json'), 'utf8'));
+        }
+        catch {
+            // wave.json illisible : la vague compte sans jetons
+        }
+        const journalFile = join(base, id, 'journal.log');
+        const journal = existsSync(journalFile) ? readFileSync(journalFile, 'utf8') : '';
+        const { waits, unfinished } = parseWaits(journal);
+        waves.push({ id, totalMs: waits.reduce((s, w) => s + w.ms, 0), count: waits.length, maxMs: Math.max(0, ...waits.map((w) => w.ms)), unfinished, status: meta.status ?? '?', consumed: meta.consumed ?? 0 });
+        const d = dayOf(idDay);
+        d.waves++;
+        d.consumed += meta.consumed ?? 0;
+        for (const day of parseQuotaStops(journal))
+            dayOf(day).quotaHits++;
+        for (const w of waits) {
+            const dw = dayOf(w.day);
+            dw.totalMs += w.ms;
+            dw.count++;
+        }
+    }
+    return { waves, days: [...days.values()].sort((a, b) => a.day.localeCompare(b.day)) };
+}
+function duration(ms) {
+    const s = Math.round(ms / 1000);
+    if (s < 60)
+        return `${s} s`;
+    const min = Math.floor(s / 60);
+    return min < 60 ? `${min} min ${String(s % 60).padStart(2, '0')} s` : `${Math.floor(min / 60)} h ${String(min % 60).padStart(2, '0')} min ${String(s % 60).padStart(2, '0')} s`;
+}
+/** Deux tableaux : par jour, puis par vague (celles qui ont attendu). */
+export function renderWaits(r) {
+    if (r.waves.length === 0)
+        return ['aucune vague dans ce dossier'];
+    const lines = ['attente de créneau de session, par jour', '  jour         attente cumulée   attentes  vagues  quota atteint  jetons'];
+    for (const d of r.days)
+        lines.push(`  ${d.day}   ${duration(d.totalMs).padEnd(16)}  ${String(d.count).padStart(8)}  ${String(d.waves).padStart(6)}  ${String(d.quotaHits).padStart(13)}  ${d.consumed}`);
+    const total = r.days.reduce((s, d) => s + d.totalMs, 0);
+    lines.push(`  total        ${duration(total)}`, '', 'par vague (celles qui ont attendu)');
+    const waited = r.waves.filter((w) => w.count > 0 || w.unfinished > 0).sort((a, b) => b.totalMs - a.totalMs);
+    if (waited.length === 0)
+        lines.push('  aucune');
+    for (const w of waited)
+        lines.push(`  ${w.id}   ${duration(w.totalMs).padEnd(16)}  ${w.count} attente(s), la plus longue ${duration(w.maxMs)}${w.unfinished ? `, ${w.unfinished} sans créneau obtenu` : ''}  [${w.status}]`);
+    return lines;
+}

package/dist/plan.js

@@ -5,7 +5,7 @@ import { isDay, toDay } from './dates.js';
 export const STATUSES = ['todo', 'doing', 'done', 'dropped'];
 export class RafError extends Error {
 }
-export const FIELDS = ['id', 'title', 'status', 'estimate', 'quickwin', 'visible', 'screen', 'public', 'every', 'last', 'after', 'created', 'started', 'finished', 'notes', 'repos', 'parent'];
+export const FIELDS = ['id', 'title', 'status', 'estimate', 'quickwin', 'visible', 'screen', 'spec', 'public', 'every', 'last', 'after', 'created', 'started', 'finished', 'notes', 'repos', 'parent'];
 /** Nature de l'écran d'un lot visible : nouvelle page, nouveau composant, parcours modifié. */
 export const SCREENS = ['page', 'component', 'journey'];
 export function isOpen(status) {
@@ -319,6 +319,8 @@ export class Plan {
             entry.visible = true;
         if (opts.screen)
             entry.screen = opts.screen;
+        if (opts.spec)
+            entry.spec = true;
         if (opts.every !== undefined)
             entry.every = opts.every;
         if (opts.after?.length)
@@ -414,6 +416,51 @@ export class Plan {
         const at = node.items.findIndex((p) => String(p.key?.value ?? p.key) === 'title');
         node.items.splice(at + 1, 0, this.doc.createPair('public', value));
     }
+    /** Pose, remplace (nature) ou retire (null) le `screen:` d'un lot existant ; exige `visible`, comme `add`. */
+    setScreen(ref, screen) {
+        this.writable();
+        if (ref.includes('/'))
+            throw new RafError(`l'écran se pose sur un lot, pas une sous-tâche : ${ref}`);
+        const node = this.lotNode(ref);
+        if (screen === null) {
+            node.delete('screen');
+            return;
+        }
+        if (!SCREENS.includes(screen))
+            throw new RafError(`screen inconnu : ${String(screen)} (${SCREENS.join(', ')}, none)`);
+        if (this.lot(ref).visible !== true)
+            throw new RafError(`${ref} n'est pas visible : un écran est un changement visible (raf add --visible)`);
+        if (node.has('screen')) {
+            node.set('screen', screen);
+            return;
+        }
+        const keys = node.items.map((p) => String(p.key?.value ?? p.key));
+        node.items.splice(keys.indexOf('visible') + 1, 0, this.doc.createPair('screen', screen));
+    }
+    /** Pose (true) ou retire (false) le `spec:` d'un lot existant ; `screen: page` l'implique, donc on ne retire pas la spec d'un lot à page (`component` et `journey` suivent le chemin ordinaire depuis L209 : leur `spec: true` est la spec back). Renvoie false quand `screen: page` rendait la pose sans objet. */
+    setSpec(ref, on) {
+        this.writable();
+        if (ref.includes('/'))
+            throw new RafError(`la spec se pose sur un lot, pas une sous-tâche : ${ref}`);
+        const node = this.lotNode(ref);
+        if (this.lot(ref).screen === 'page') {
+            if (!on)
+                throw new RafError(`${ref} a screen: page — retirer d'abord screen: (raf screen ${ref} none), l'écran implique la spec`);
+            return false;
+        }
+        if (!on) {
+            node.delete('spec');
+            return true;
+        }
+        if (node.has('spec')) {
+            node.set('spec', true);
+            return true;
+        }
+        const keys = node.items.map((p) => String(p.key?.value ?? p.key));
+        const at = Math.max(...['screen', 'visible', 'quickwin', 'estimate'].map((k) => keys.indexOf(k)));
+        node.items.splice(at + 1, 0, this.doc.createPair('spec', true));
+        return true;
+    }
     /** Un lot récurrent a été refait : `last` passe à aujourd'hui, avec une note si `text` est donné. */
     did(ref, today, text) {
         this.writable();
@@ -483,6 +530,8 @@ function foreignLots(raw, format) {
             quickwin: pick('quickwin'),
             visible: pick('visible'),
             screen: pick('screen'),
+            // Le `spec:` d'un plan tenu par un autre outil n'est à nous que s'il est mappé, et seul `true` compte : ailleurs c'est souvent un chemin de document (L198).
+            spec: format.fields.spec && pick('spec') === true ? true : undefined,
             public: pick('public'),
             every: pick('every'),
             last: day('last'),
@@ -539,6 +588,13 @@ function normalizeLot(raw, problems = []) {
         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)} »)`);
+    }
     return {
         id: String(raw.id),
         title: String(raw.title ?? ''),
@@ -547,6 +603,7 @@ function normalizeLot(raw, problems = []) {
         quickwin: raw.quickwin === true,
         visible: raw.visible === true,
         ...(screen ? { screen } : {}),
+        ...(spec ? { spec } : {}),
         ...(typeof raw.public === 'string' && raw.public.trim() !== '' ? { public: raw.public.trim() } : {}),
         ...(Number.isInteger(raw.every) && raw.every > 0 ? { every: raw.every } : {}),
         ...(last ? { last } : {}),