@sylad/cadence 1.34.1 → 1.36.0

package/dist/deliver.js

@@ -6,16 +6,14 @@ import { parse } from 'yaml';
 import { onTermination, readProcs, SIGNAL_GRACE_MS, SIGNAL_PENDING_MS, TreeTracker } from './proc.js';
 import { deliveryLots, isPlanOnly } from './audit.js';
 import { commitPaths, dirtyPaths, headSha, isAncestor, onRemote, readCommits, repoStatus, resolveCommit } from './git.js';
+import { planOnlySince, pollGithubCi, stamped, stepJournal } from './deliver-ci.js';
 import { PLAN_ACTIONS, planCommitMessage } from './plan-commit.js';
 import { citedRefs } from './link.js';
 import { describeArticle, openArticleLots } from './articles.js';
 import { RafError } from './plan.js';
 import { appendDelivery, appendFailedDelivery, lastDelivery, lockAlive, lockFault, lockPath, readLock, releaseLock, removeStaleLock, writeLock } from './state.js';
-const POLL_CI = 15_000;
-const CI_APPEAR = 300_000;
 /** Intervalle de réessai d'une vérification : celui de deliver ET de `cadence verify --retry`. */
 const POLL_VERIFY = 10_000;
-const CI_OK = new Set(['success', 'skipped', 'neutral']);
 const GH_TIMEOUT = 60_000;
 export const TIMED_OUT = 124;
 /** Sortie gardée d'une commande : de quoi retrouver ses dernières lignes. */
@@ -236,6 +234,32 @@ export function describeCheck(c, sha) {
     return `GET ${substitute(c.url, sha)} → ${c.status ?? 200}${c.contains === undefined ? '' : `, contient « ${substitute(c.contains, sha)} »`}`;
 }
 const guardMessage = (sha, lots) => `${sha.slice(0, 7)} contient des commits de lots ni terminés ni prêts : ${lots.map((l) => `${l.id} (${l.state})`).join(', ')} ; livrer un sha antérieur, ou relire ces lots (raf review) avant`;
+/** La simulation de `--dry-run` : ce que la livraison jouerait, sans rien exécuter. */
+function describeSimulation(ctx, sha, env, branch, script) {
+    const { config, out } = ctx;
+    out(`Livraison de ${env.CADENCE_SHORT} (${branch}) — simulation, rien n'est exécuté`);
+    if (script !== null) {
+        out(`  Script du projet : ${script}`);
+        out(`    (CI, déploiement et contrôles métier sont les siens ; délai ${config.deployTimeout} s)`);
+    }
+    else {
+        const skipped = config.ci === 'none' ? null : planOnlySince(ctx, sha);
+        if (skipped)
+            out(`  CI : non attendue (aucun fichier hors plan depuis ${skipped.slice(0, 7)})`);
+        else
+            out(`  CI : ${typeof config.ci === 'string' ? config.ci : config.ci.command}${config.ci === 'none' ? '' : ` (délai ${config.ciTimeout} s)`}`);
+        out('  Déploiement :');
+        if (config.deploy.length === 0)
+            out('    (aucune commande)');
+        config.deploy.forEach((c, i) => out(`    ${i + 1}. ${c}`));
+    }
+    if (ctx.articles?.length)
+        out(`  Articles rafraîchis après une livraison verte (lot « Article <projet> à rafraîchir ») : ${ctx.articles.map(describeArticle).join(', ')}`);
+    if (config.verify.length)
+        out(`  Vérifications (réessayées pendant ${config.verifyTimeout} s) :`);
+    config.verify.forEach((c, i) => out(`    ${i + 1}. ${describeCheck(c, sha)}`));
+    out(`  Variables : ${Object.entries(env).map(([k, v]) => `${k}=${v}`).join(' ')}`);
+}
 /** Livre HEAD. 0 livré, 1 étape en échec, 2 refus avant d'agir. */
 export async function deliver(ctx, deps) {
     const { config, out, err } = ctx;
@@ -293,24 +317,7 @@ export async function deliver(ctx, deps) {
     const branch = atHead ? (repo.branch ?? 'HEAD détachée') : 'sha choisi, antérieur ou étranger à la tête';
     const env = { CADENCE_SHA: sha, CADENCE_SHORT: sha.slice(0, 7), CADENCE_BRANCH: atHead ? (repo.branch ?? '') : '' };
     if (ctx.dryRun) {
-        out(`Livraison de ${env.CADENCE_SHORT} (${branch}) — simulation, rien n'est exécuté`);
-        if (script !== null) {
-            out(`  Script du projet : ${script}`);
-            out(`    (CI, déploiement et contrôles métier sont les siens ; délai ${config.deployTimeout} s)`);
-        }
-        else {
-            out(`  CI : ${typeof config.ci === 'string' ? config.ci : config.ci.command}${config.ci === 'none' ? '' : ` (délai ${config.ciTimeout} s)`}`);
-            out('  Déploiement :');
-            if (config.deploy.length === 0)
-                out('    (aucune commande)');
-            config.deploy.forEach((c, i) => out(`    ${i + 1}. ${c}`));
-        }
-        if (ctx.articles?.length)
-            out(`  Articles rafraîchis après une livraison verte (lot « Article <projet> à rafraîchir ») : ${ctx.articles.map(describeArticle).join(', ')}`);
-        if (config.verify.length)
-            out(`  Vérifications (réessayées pendant ${config.verifyTimeout} s) :`);
-        config.verify.forEach((c, i) => out(`    ${i + 1}. ${describeCheck(c, sha)}`));
-        out(`  Variables : ${Object.entries(env).map(([k, v]) => `${k}=${v}`).join(' ')}`);
+        describeSimulation(ctx, sha, env, branch, script);
         if (undelivered.length)
             return refuse(guardMessage(sha, undelivered));
         return 0;
@@ -328,6 +335,7 @@ export async function deliver(ctx, deps) {
     }
     if (!taken)
         return refuse('une autre livraison vient de démarrer');
+    const startedAt = deps.now();
     try {
         const fail = (msg, cls, tail = []) => {
             err(`deliver : ${msg}`);
@@ -341,9 +349,10 @@ export async function deliver(ctx, deps) {
             return 1;
         };
         out(`Livraison de ${env.CADENCE_SHORT} (${branch})`);
+        const step = stepJournal(ctx, deps, sha, () => deliveredIds(ctx, lastDelivery(ctx.state), sha));
         let declared = null;
         if (script !== null) {
-            out(`→ script du projet : ${script}`);
+            out(stamped(deps, `→ script du projet : ${script}`));
             // Le script qui déploie un autre commit que CADENCE_SHA y écrit son sha : cadence ne le devine pas.
             const file = join(ctx.state, `deployed-${process.pid}`);
             try {
@@ -368,18 +377,28 @@ export async function deliver(ctx, deps) {
             }
         }
         else {
-            const ci = await waitCi(ctx, deps, sha, env);
-            // Seule une commande de CI a une sortie : pour `ci: github`, lastOutput serait celle d'une commande antérieure.
-            if (ci)
-                return fail(ci, 'ci', typeof config.ci === 'object' ? deps.lastOutput?.() : []);
+            const skipped = config.ci === 'none' ? null : planOnlySince(ctx, sha);
+            if (skipped)
+                out(stamped(deps, `→ CI : non attendue (aucun fichier hors plan depuis ${skipped.slice(0, 7)})`));
+            else {
+                const ciStart = deps.now();
+                const ci = await waitCi(ctx, deps, sha, env);
+                if (config.ci !== 'none')
+                    step('ci', ciStart, ci === null);
+                // Seule une commande de CI a une sortie : pour `ci: github`, lastOutput serait celle d'une commande antérieure.
+                if (ci)
+                    return fail(ci, 'ci', typeof config.ci === 'object' ? deps.lastOutput?.() : []);
+            }
             for (const [i, cmd] of config.deploy.entries()) {
-                out(`→ déploiement ${i + 1}/${config.deploy.length} : ${cmd}`);
+                out(stamped(deps, `→ déploiement ${i + 1}/${config.deploy.length} : ${cmd}`));
+                const deployStart = deps.now();
                 const code = await deps.exec(cmd, env, config.deployTimeout * 1000);
+                step(`deploiement ${i + 1}/${config.deploy.length}`, deployStart, code === 0);
                 if (code !== 0)
                     return fail(`déploiement en échec (${codeText(code)}) : ${cmd}`, 'deploiement', deps.lastOutput?.());
             }
         }
-        const failed = await verifyAll(ctx, deps, sha, env);
+        const failed = await verifyAll(ctx, deps, sha, env, step);
         if (failed)
             return fail(failed.message, 'verification', failed.tail);
         // Ce qui est journalisé : le sha que le script déclare (CADENCE_DEPLOYED_FILE) l'emporte. Sans déclaration, hors vague, un script qui a commité
@@ -406,12 +425,13 @@ export async function deliver(ctx, deps) {
         const ids = deliveredIds(ctx, lastDelivery(ctx.state), final);
         const delivered = deliveredLots(ctx, ids, lastDelivery(ctx.state), final);
         appendDelivery(ctx.state, ctx.today, final);
+        const took = `en ${Math.round((deps.now() - startedAt) / 1000)} s`;
         if (how === 'declared')
-            out(`✓ livré : ${final.slice(0, 7)} (sha déclaré par le script)`);
+            out(stamped(deps, `✓ livré : ${final.slice(0, 7)} (sha déclaré par le script) ${took}`));
         else if (how === 'moved')
-            out(`✓ livré : ${final.slice(0, 7)} (tête déplacée par le script depuis ${env.CADENCE_SHORT})`);
+            out(stamped(deps, `✓ livré : ${final.slice(0, 7)} (tête déplacée par le script depuis ${env.CADENCE_SHORT}) ${took}`));
         else
-            out(`✓ livré${config.verify.length ? ' et vérifié' : ''} : ${env.CADENCE_SHORT}`);
+            out(stamped(deps, `✓ livré${config.verify.length ? ' et vérifié' : ''} : ${env.CADENCE_SHORT} ${took}`));
         if (delivered)
             out(delivered);
         refreshArticles(ctx, ids, final);
@@ -427,51 +447,11 @@ async function waitCi(ctx, deps, sha, env) {
     if (ci === 'none')
         return null;
     if (typeof ci === 'object') {
-        ctx.out(`→ CI : ${ci.command}`);
+        ctx.out(stamped(deps, `→ CI : ${ci.command}`));
         const code = await deps.exec(ci.command, env, ciTimeout * 1000);
         return code === 0 ? null : `CI en échec (${codeText(code)}) : ${ci.command}`;
     }
-    ctx.out(`→ CI : attente des runs GitHub de ${sha.slice(0, 7)}`);
-    const start = deps.now();
-    let last = '';
-    let failingSince = null;
-    for (;;) {
-        let runs = [];
-        let error = null;
-        try {
-            runs = deps.gh(sha);
-            failingSince = null;
-        }
-        catch (e) {
-            // Erreur passagère (réseau, quota d'API) : on réessaie ; persistante, on abandonne avec sa cause.
-            error = e.message;
-            failingSince ??= deps.now();
-        }
-        const elapsed = deps.now() - start;
-        if (error !== null) {
-            if (deps.now() - failingSince >= CI_APPEAR || elapsed >= ciTimeout * 1000)
-                return `gh run list en échec : ${error}`;
-            ctx.err(`  gh run list en échec, nouvel essai : ${error}`);
-        }
-        else if (runs.length === 0) {
-            if (elapsed >= CI_APPEAR)
-                return `aucun run CI pour ce sha après ${CI_APPEAR / 60_000} min (le commit poussé est-il celui que la CI construit ?)`;
-        }
-        else {
-            const pending = runs.filter((r) => r.status !== 'completed');
-            const summary = `${runs.length} run(s), ${runs.length - pending.length} terminé(s)`;
-            if (summary !== last)
-                ctx.out(`  ${summary}`);
-            last = summary;
-            if (pending.length === 0) {
-                const bad = runs.filter((r) => !CI_OK.has(r.conclusion));
-                return bad.length ? `CI en échec : ${bad.map((r) => `${r.name} (${r.conclusion})`).join(', ')}` : null;
-            }
-        }
-        if (elapsed >= ciTimeout * 1000)
-            return `CI non terminée après ${ciTimeout} s`;
-        await deps.sleep(POLL_CI);
-    }
+    return pollGithubCi(ctx, deps, sha);
 }
 /** Un essai d'une vérification : cause de l'échec, ou null. Partagé par deliver et `cadence verify`. */
 async function tryCheck(c, deps, sha, env, budgetMs) {
@@ -510,12 +490,14 @@ export async function retryCheck(c, deps, sha, env, until, attemptMs) {
     }
 }
 /** Chaque vérification est réessayée jusqu'au délai commun ; message d'échec ou null. */
-async function verifyAll(ctx, deps, sha, env) {
+async function verifyAll(ctx, deps, sha, env, step) {
     const deadline = deps.now() + ctx.config.verifyTimeout * 1000;
     for (const [i, c] of ctx.config.verify.entries()) {
         const label = describeCheck(c, sha);
-        ctx.out(`→ vérification ${i + 1}/${ctx.config.verify.length} : ${label}`);
+        ctx.out(stamped(deps, `→ vérification ${i + 1}/${ctx.config.verify.length} : ${label}`));
+        const checkStart = deps.now();
         const reason = await retryCheck(c, deps, sha, env, deadline, () => deadline - deps.now());
+        step(`verification ${i + 1}/${ctx.config.verify.length}`, checkStart, reason === null);
         if (reason !== null)
             return { message: `vérification en échec après ${ctx.config.verifyTimeout} s : ${label} — ${reason}`, tail: c.command !== undefined ? (deps.lastOutput?.() ?? []) : [] };
     }
@@ -557,8 +539,8 @@ function deliveredLots(ctx, ids, prev, sha) {
 }
 /**
  * Livraison verte (L144) : les lots livrés dont le titre est public changent ce que les articles externes racontent, on ouvre
- * donc le lot qui les rafraîchit. Hors vague le plan est écrit mais pas commité ; pendant une vague (L388) il est commité avec les fichiers que produit `plan.onWrite`, avec
- * le gabarit `plan.commit`, pour ne pas laisser le plan modifié dans l'arbre où une session de la vague travaille — sauf si le plan ou ces fichiers l'étaient
+ * donc le lot qui les rafraîchit. Le plan est commité (L388 pendant une vague, L420 aussi hors vague : le livreur lancé à la main le laissait modifié) avec les fichiers que produit `plan.onWrite`, avec
+ * le gabarit `plan.commit` (sans la vague hors vague), pour ne pas laisser le plan modifié dans l'arbre — sauf si le plan ou ces fichiers l'étaient
  * déjà avant l'écriture (le lead y a des modifications que ce commit emporterait). Une erreur ici ne défait pas une livraison déjà faite.
  */
 function refreshArticles(ctx, ids, sha) {
@@ -586,10 +568,10 @@ function refreshArticles(ctx, ids, sha) {
             plan.save();
         const touched = [...r.opened, ...r.noted];
         let state = 'plan modifié, à commiter';
-        if (touched.length && ctx.duringWave && wasDirty) {
+        if (touched.length && wasDirty) {
             state = 'plan déjà modifié avant la livraison, non commité : à commiter avec vos modifications';
         }
-        else if (touched.length && ctx.duringWave) {
+        else if (touched.length) {
             const message = planCommitMessage(ctx.planCommit, { lot: touched.join(', '), action: r.opened.length ? PLAN_ACTIONS.articleOpened : PLAN_ACTIONS.articleNoted, wave: ctx.waveId });
             try {
                 state = `plan commité ${commitPaths(ctx.root, [planFile, ...dirtyPaths(ctx.root, plan.produced)], message)}`;

package/dist/gate-config.js

@@ -0,0 +1,47 @@
+import { isAbsolute } from 'node:path';
+/** Un chemin de test relatif au dépôt, sans « .. » (`gate.readsPlan`). */
+const relativeTest = (x) => typeof x === 'string' && !!x.trim() && !isAbsolute(x) && !x.split(/[\\/]/).includes('..');
+/** `gate.readsPlan` : true, une liste de chemins de tests, false ou absent (rien d'actif). */
+function readsPlanOf(r, bad, others) {
+    if (r === true)
+        return true;
+    if (Array.isArray(r) && r.length && r.every(relativeTest))
+        return r.map((x) => x.trim());
+    // Sans `host` ni `install`, `gate: {}` ne déclare rien : refusé comme avant.
+    if (r === false || (r == null && others))
+        return undefined;
+    throw bad('gate.readsPlan : true, false ou liste de chemins de tests relatifs au dépôt, sans « .. »');
+}
+/** `gate.host` : une destination ssh, sans espace ; une qui commencerait par « - » serait lue par ssh comme une option (-oProxyCommand=…). */
+function hostOf(v, bad) {
+    const h = typeof v === 'string' ? v.trim() : '';
+    if (!h || /\s/.test(h) || h.startsWith('-'))
+        throw bad('gate.host : destination ssh attendue (une chaîne sans espace, ne commençant pas par « - »)');
+    return h;
+}
+/** `gate.install` : une commande non vide. */
+function installOf(v, bad) {
+    if (typeof v !== 'string' || !v.trim())
+        throw bad('gate.install : commande non vide attendue');
+    return v.trim();
+}
+/**
+ * Clé `orchestrate.gate` de cadence.yaml : `readsPlan` (L450), `host` et `install` (L403). Rend undefined quand elle ne déclare rien d'actif (`readsPlan: false` seul) ;
+ * `host` ou `install` seuls posent la clé sans `readsPlan` : déclarer l'hôte ne vaut pas déclarer que des tests lisent le plan (R11).
+ * `bad` fabrique l'erreur de config préfixée (`cadence.yaml : orchestrate.<what>`).
+ */
+export function readGate(raw, bad) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        throw bad('gate : objet attendu (gate: { readsPlan: true })');
+    const o = raw;
+    for (const k of Object.keys(o))
+        if (!['readsPlan', 'host', 'install'].includes(k))
+            throw bad(`gate.${k} inconnu (attendu : readsPlan, host, install)`);
+    const readsPlan = readsPlanOf(o.readsPlan, bad, o.host != null || o.install != null);
+    const gate = {
+        ...(readsPlan ? { readsPlan } : {}),
+        ...(o.host != null ? { host: hostOf(o.host, bad) } : {}),
+        ...(o.install != null ? { install: installOf(o.install, bad) } : {}),
+    };
+    return Object.keys(gate).length ? gate : undefined;
+}

package/dist/orchestrate/accept.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, posix } from 'node:path';
 import { parse } from 'yaml';
 import { citedRefs } from '../link.js';
+import { isParts } from './gate-parts.js';
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function git(repo, ...args) {
     return execFileSync('git', args, { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024 });
@@ -461,6 +462,8 @@ export function planAcceptRuns(commands, fichiers, single = false) {
     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. */
+/** La commande ordinaire du projet dans le prompt de la session accept : une chaîne telle quelle, une porte en parties (L512) partie par partie avec son dossier. */
+const ordinaryText = (t) => (!t ? '' : isParts(t) ? ` The project's ordinary test commands, one per folder, are ${t.map((p) => `\`${p.run}\` (in \`${p.dir}/\`)`).join(', ')}: they must stay green with your red tests committed.` : ` The project's ordinary test command is \`${t}\`: it must stay green with your red tests committed.`);
 export function acceptText(o) {
     const commands = acceptCommands(o.command);
     const screen = o.screen !== false;
@@ -469,8 +472,8 @@ export function acceptText(o) {
             ? `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.` : ''}`,
+            ? `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\`.${ordinaryText(o.test)}`
+            : `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).${ordinaryText(o.test)}`,
         `If \`${o.acceptation}\` already exists with \`vert: true\` and \`empreintes\`, the lot's oracle is green and sealed: never rewrite it, nor its tests, \`resceaux\` or \`empreintes\`, and never set \`vert\` (a corrected test is resealed by the lead, \`cadence spec reseal\`). Write nothing, commit nothing, and hand the lot back with that finding in \`questions\`. A \`vert: true\` file WITHOUT \`empreintes\` (or whose \`empreintes\` lack one of the listed test files) was never sealed by the program (only the cycle sets \`vert\`, after the seal): it proves nothing, so write the oracle as described below, with \`vert: false\`.`,
         `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). If the tests need a build or a browser (Playwright, Chromium, \`dist\`), add \`"e2e": true\` to it: those files then stay out of the ordinary runner and the unit CI even once green (they would turn it red without \`dist\` or Chromium) and belong to the project's e2e suite, run after the build (\`acceptationE2e()\` of the runner template lists them). 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\`):`,
     ];

package/dist/orchestrate/ajout.js

@@ -0,0 +1,186 @@
+import { basename, join, relative, resolve } from 'node:path';
+import { lotFinished, lotKey, lotRepoPaths } from './state.js';
+import { cadenceHome, liveWaves } from './registry.js';
+import { REPO_LOCK, takeLock } from './lock.js';
+import { installPrePush } from './guard.js';
+import { sharedStateDir } from '../state.js';
+import { waveReadsAdds } from './snapshot.js';
+const ALONE = ['lots', 'resume', 'status', 'drop', 'stopAfterCurrent', 'budget', 'lotBudgets', 'dryRun', 'continue', 'answers', 'integrate', 'removeWorktree', 'waits', 'goal', 'maxSessions'];
+/** `--add` ne se combine avec rien d'autre que `--wave` (L421) : vrai quand une autre action est donnée. */
+export const addNotAlone = (args) => ALONE.some((k) => (Array.isArray(args[k]) ? args[k].length > 0 : !!args[k] || args[k] === 0));
+/**
+ * L'identifiant d'un projet dans la vague, le même quelle que soit la façon de le taper : le chemin donné résolu depuis le dossier de lancement (`./b`, `b/../b` → `b`),
+ * et le nom du dossier de lancement quand le projet est ce dossier (`.`, ou rien). Sans cela une vague lancée dans un dépôt avec `L1` rangeait son lot sous `a:L1` et
+ * `--add .:L2` cherchait ses lots et ses doublons sous `.` : dépendance non reconnue, doublon admis.
+ */
+export function projectName(cwd, project) {
+    if (!project)
+        return basename(cwd);
+    return relative(cwd, resolve(cwd, project)) || basename(cwd);
+}
+/** La clé d'un lot tel que la vague le range : le projet résolu (`projectName`) et le lot. */
+export const addKey = (launch, t) => lotKey(projectName(launch, t.project), t.lot);
+/** La commande qui ajoute le lot à la vague vivante qui tient le dépôt, quand cette vague a été lancée depuis ce dossier (`--add` ne voit que celles-là) ; sinon rien. */
+export function addHint(t, wave, launch) {
+    if (!liveWaves(cadenceHome()).some((w) => w.wave === wave && w.cwd === launch))
+        return '';
+    return ` ; pour y ajouter ce lot : cadence orchestrate --add ${relative(launch, t.projectDir) || '.'}:${t.lot} --wave ${wave}`;
+}
+/** Refus d'un ajout (code 2) ou rien : les lots déjà dans la vague ou en file ne sont pas rejoués, le budget restant doit tenir celui de chaque lot ajouté. */
+function budgetRefusals(lots, wave) {
+    let remaining = wave ? wave.budget - wave.consumed : Infinity;
+    const out = [];
+    for (const l of lots) {
+        if (l.budget > remaining)
+            out.push(`${lotKey(l.project, l.lot)} : le budget restant de la vague (${Math.max(0, Math.round(remaining))} tokens) ne tient pas le budget du lot (${l.budget})`);
+        remaining -= l.budget;
+    }
+    return out;
+}
+/**
+ * `--add` sur une vague VIVANTE (L421) : chaque lot passe le contrôle préalable d'un lot donné au lancement (dépôt tenu par CETTE vague admis, dépendances comptées dans la vague), puis est déposé
+ * dans la file d'ajouts que la vague prend entre deux étapes. Tout est refusé avant d'agir (code 2) dès qu'un lot l'est, comme `--answer`.
+ */
+export async function addToLive(args, run, store, checks) {
+    const { io, launch } = run;
+    const refusals = [];
+    const targets = checks.resolveTargets({ lots: args.add }, io, refusals);
+    if (!waveReadsAdds(store.dir))
+        refusals.push(`la vague ${store.id} ne lit pas la file d'ajouts (lancée avec une version de cadence d'avant L421) : attendre sa fin, puis lancer le lot dans une vague`);
+    const queued = store.addQueue().map((e) => ({ project: projectName(launch, e.project), lot: e.lot, queued: true }));
+    const pre = refusals.length ? { refusals: [], lots: [] } : await checks.preflight(targets, run, { wave: store.id, lots: [...store.lots(), ...queued] });
+    refusals.push(...pre.refusals, ...budgetRefusals(pre.lots, store.readWave()));
+    if (refusals.length) {
+        for (const r of refusals)
+            io.err(`orchestrate : ${r}`);
+        return 2;
+    }
+    for (const a of args.add) {
+        const key = addKey(launch, a);
+        const id = store.requestAdd({ project: a.project, lot: a.lot, model: a.model });
+        // La vague a pu finir entre le contrôle et le dépôt : sa file ne sera plus lue, la demande est retirée.
+        if (!liveWaves(cadenceHome()).some((w) => w.wave === store.id)) {
+            store.markAddTaken(id);
+            io.err(`orchestrate : ${key} : la vague ${store.id} vient de finir, lot non ajouté : le lancer dans une nouvelle vague`);
+            return 2;
+        }
+        store.journal(`demande : ajouter ${key} à la vague`);
+        io.out(`${key} : ajout déposé — la vague ${store.id} le prend entre deux étapes et le joue dès qu'un créneau est libre`);
+    }
+    return 0;
+}
+/**
+ * Les lots déposés par `--add` (L421), pris par la vague entre deux étapes comme les réponses du lead. Un lot dont le dépôt est occupé par un lot qui joue attend dans `waiting`
+ * (son contexte n'est pas reconstruit à chaque tour, mais ce qui l'écarterait est relu au moment de le prendre) ; un lot qui ne tient plus à cet instant est écarté et dit au journal.
+ */
+export class AddFeed {
+    e;
+    waiting = new Map();
+    constructor(e) {
+        this.e = e;
+    }
+    discard(entry, why) {
+        this.e.wctx.log(`${addKey(this.e.launch, entry)} : ajout écarté (${why})`);
+        this.e.store.markAddTaken(entry.id);
+        this.waiting.delete(entry.id);
+        return null;
+    }
+    /** Le contexte du lot demandé, contrôlé comme au lancement ; null quand il est écarté (dit au journal). */
+    async prepare(entry) {
+        const e = this.e;
+        const key = addKey(e.launch, entry);
+        const stop = e.stopCause();
+        if (stop)
+            return this.discard(entry, stop);
+        const refusals = [];
+        const targets = e.checks.resolveTargets({ lots: [{ project: entry.project, lot: entry.lot, model: entry.model }] }, e.io, refusals);
+        const known = [...e.ctxs, ...this.waiting.values()].map((c) => ({ project: c.lot.project, lot: c.lot.lot }));
+        const built = refusals.length ? { refusals } : await e.build(targets[0], known);
+        if ('refusals' in built)
+            return this.discard(entry, built.refusals.map((r) => (r.startsWith(`${key} : `) ? r.slice(key.length + 3) : r)).join(' ; '));
+        if (built.ctx.lot.budget > e.budgetLeft())
+            return this.discard(entry, `le budget restant de la vague ne tient pas le budget du lot (${built.ctx.lot.budget})`);
+        return built.ctx;
+    }
+    /** Un ajout resté en attente est recontrôlé quand la vague le prend : arrêt demandé, budget épuisé ou lot fini entre-temps l'écartent comme à la lecture de la file. */
+    recheck(entry, c) {
+        const e = this.e;
+        const why = e.stopCause() ?? (c.lot.budget > e.budgetLeft() ? `le budget restant de la vague ne tient pas le budget du lot (${c.lot.budget})` : e.planState(c));
+        return why ? this.discard(entry, why) : c;
+    }
+    /** Prend le verrou et la garde de push d'un dépôt que la vague ne tient pas (ou plus) ; rend la cause du refus. */
+    hold(repo, fresh) {
+        const e = this.e;
+        const file = join(sharedStateDir(repo), REPO_LOCK);
+        if (e.held.includes(file))
+            return null;
+        const l = takeLock(file, { pid: process.pid, wave: e.wave.id, started: new Date().toISOString() });
+        if (!l.ok && l.held.pid !== process.pid)
+            return `${basename(repo)} : une orchestration y est déjà en cours (${l.held.wave}, pid ${l.held.pid})`;
+        e.held.push(file);
+        fresh.push(repo);
+        if (l.ok && l.stale)
+            e.wctx.log(`orchestrate : verrou de dépôt périmé retiré (${basename(repo)}, pid ${l.stale.pid} mort)`);
+        const hook = installPrePush(repo, e.wave.id);
+        if (!hook.ok)
+            return `${basename(repo)} : ${hook.reason}`;
+        e.freed.delete(repo);
+        if (!e.repos.includes(repo))
+            e.repos.push(repo);
+        return null;
+    }
+    /** Les verrous de tous les dépôts du lot ; en cas de refus, ceux pris pour lui sont rendus. */
+    holdAll(c) {
+        const fresh = [];
+        const refused = lotRepoPaths(c.lot).map((r) => this.hold(r, fresh)).find((x) => x) ?? null;
+        if (refused)
+            for (const r of fresh)
+                this.e.freeRepo(r);
+        return refused;
+    }
+    admit(entry, c) {
+        const e = this.e;
+        e.ctxs.push(c);
+        e.all.push(c.lot);
+        if (e.lots !== e.all)
+            e.lots.push(c.lot);
+        e.wave.lots.push(lotKey(c.lot.project, c.lot.lot));
+        e.store.writeLot(c.lot);
+        e.saveWave();
+        e.store.markAddTaken(entry.id);
+        this.waiting.delete(entry.id);
+        e.wctx.log(`${lotKey(c.lot.project, c.lot.lot)} : ajouté à la vague ${e.wave.id}`);
+    }
+    /** Les lots ajoutés à ce tour, prêts à être joués ; `canRun` dit si le dépôt du lot est libre (jamais deux sessions dans un même dépôt hors worktree). */
+    async take(canRun) {
+        const added = [];
+        for (const entry of this.e.store.addQueue()) {
+            const kept = this.waiting.get(entry.id);
+            const c = kept ? this.recheck(entry, kept) : await this.prepare(entry);
+            if (!c)
+                continue;
+            if (!canRun(c)) {
+                this.waiting.set(entry.id, c);
+                continue;
+            }
+            const refused = this.holdAll(c);
+            if (refused)
+                this.discard(entry, refused);
+            else {
+                this.admit(entry, c);
+                added.push(c);
+            }
+        }
+        if (added.length)
+            this.e.announce();
+        return added;
+    }
+    /** Les demandes encore en file quand plus rien ne joue ne seront plus lues : écartées et dites. */
+    drain(why) {
+        this.waiting.clear();
+        for (const entry of this.e.store.addQueue())
+            this.discard(entry, why);
+    }
+}
+/** Un lot est-il encore à jouer dans ce dépôt (utilisé pour décider d'un worktree) ? */
+export const openInRepo = (ctxs, c) => ctxs.filter((o) => !lotFinished(o.lot) && lotRepoPaths(o.lot).some((r) => lotRepoPaths(c.lot).includes(r)));

package/dist/orchestrate/baseline.js

@@ -61,6 +61,63 @@ export function unloadedSuites(output) {
     }
     return [...found].sort();
 }
+/** Le délai d'un test expiré : vitest « Test timed out in 30000ms », jest « Exceeded timeout of 5000 ms for a test ». */
+const SUMMARY = /^\s*(?:Test Files?|Tests?)\s+\d/;
+const TIMEOUT = /(?:timed out in|Exceeded timeout of)\s+(\d+)\s*ms/i;
+/**
+ * Le délai (ms) de chaque test qui a expiré dans la sortie d'un lanceur (L510) : le message d'expiration est lu sous le dernier test nommé rouge qui le précède, avec le nom que donne `failedTests`.
+ * Un message sans test nommé avant lui ne désigne rien et n'est pas retenu.
+ */
+export function timeoutLimits(output) {
+    const limits = new Map();
+    let current = null;
+    for (const raw of stripAnsi(output).split('\n')) {
+        if (FILE_LOAD_FAIL.test(raw))
+            continue;
+        current = namedFailure(raw, current);
+        const t = TIMEOUT.exec(raw);
+        if (t && current)
+            limits.set(current, Number(t[1]));
+    }
+    return limits;
+}
+/** Le test rouge qu'une ligne nomme, null quand elle ouvre un résumé de fin ou un nom vide, `current` quand elle n'en nomme aucun. */
+function namedFailure(raw, current) {
+    if (SUMMARY.test(raw))
+        return null;
+    for (const re of MARKERS) {
+        const m = re.exec(raw);
+        if (!m)
+            continue;
+        const name = clean(m[1]);
+        return name && !/^(?:Test Files?|Tests?)\b/.test(name) ? name : null;
+    }
+    return current;
+}
+/**
+ * La durée (ms) que la sortie d'un rejeu donne au test `name` du fichier `file` : la ligne du test (son dernier segment « suite > test » ou « Suite › test ») qui finit par une durée, sinon la ligne ✓ du fichier (« ✓ a.test.ts (3 tests) 24s »,
+ * une borne haute pour le test). Null quand aucune durée ne se lit.
+ */
+export function testDurationMs(output, name, file) {
+    const leaf = name.split(/ > | › /).pop().trim();
+    const lines = stripAnsi(output).split('\n');
+    const byTest = leaf ? lines.find((l) => lineDurationMs(l) !== null && endsWithName(l, leaf)) : undefined;
+    if (byTest)
+        return lineDurationMs(byTest);
+    const byFile = lines.find((l) => /^\s*[✓√]/.test(l) && l.includes(file) && lineDurationMs(l) !== null);
+    return byFile ? lineDurationMs(byFile) : null;
+}
+const DURATION_END = /\s*\(?(\d+(?:\.\d+)?)\s*(ms|s)\)?\s*$/;
+/** La durée (ms) qui finit une ligne de lanceur, null sans durée. */
+function lineDurationMs(l) {
+    const m = DURATION_END.exec(l);
+    return m ? Math.round(Number(m[1]) * (m[2] === 's' ? 1000 : 1)) : null;
+}
+/** La ligne finit par `leaf` (puis sa durée), au début d'un mot : un nom qui n'est que le sous-texte d'un voisin (« plan » / « plan-data ») ne la désigne pas. */
+function endsWithName(l, leaf) {
+    const bare = l.replace(DURATION_END, '').trimEnd();
+    return bare.endsWith(leaf) && (bare.length === leaf.length || /[\s>›]/.test(bare[bare.length - leaf.length - 1]));
+}
 /** Sortie sans les séquences de couleur du lanceur. */
 export const stripAnsi = (s) => s.replace(ANSI, '');
 /**

package/dist/orchestrate/briefs.js

@@ -1,4 +1,5 @@
 import { readFileSync } from 'node:fs';
+import { isParts } from './gate-parts.js';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { RafError } from '../plan.js';
@@ -133,7 +134,9 @@ export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
  * alors que la porte joue `npx tsc --noEmit` (test et scripts compris) : L330, L353. Vide sans commande déclarée.
  */
 export function gateText(gate) {
-    const lines = [gate.test ? `- tests: \`${gate.test}\`` : '', gate.build ? `- build: \`${gate.build}\`` : ''].filter(Boolean);
+    // Porte en parties (L512) : une ligne par partie, avec son dossier, jamais la liste sérialisée.
+    const tests = !gate.test ? [] : isParts(gate.test) ? gate.test.map((p) => `- tests (run in \`${p.dir}/\`): \`${p.run}\``) : [`- tests: \`${gate.test}\``];
+    const lines = [...tests, gate.build ? `- build: \`${gate.build}\`` : ''].filter(Boolean);
     if (!lines.length)
         return '';
     return `The program's gate, played after every writing session, is exactly:\n${lines.join('\n')}\nRun these commands as written before reporting, not a narrower one (\`npm run build\` or \`npm test\` may cover less than the gate). A red there sends the lot back to a correction pass even when your own run was green.`;