@sylad/cadence 1.35.0 → 1.37.0

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "cadence",
       "description": "Session start and close rituals driven by a versioned plan (raf), and deliveries proven by their effect. Needs the cadence CLI (npm i -g @sylad/cadence).",
-      "version": "1.35.0",
+      "version": "1.37.0",
       "source": "./",
       "author": {
         "name": "Sylvain Ladoire"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cadence",
   "description": "A repo-native working method: session start and close rituals driven by a versioned plan (raf), deliveries proven by their effect, and three reviewer agents (UX, code, QA).",
-  "version": "1.35.0",
+  "version": "1.37.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/README.md

@@ -49,12 +49,12 @@ Details: [docs/skills.md](docs/skills.md) and [docs/cadence-hud.md](docs/cadence
 
 - [docs/raf.md](docs/raf.md): the plan, its commands and its file.
 - [docs/orchestrate.md](docs/orchestrate.md): waves, budgets, and [the edge-case probe](docs/orchestrate.md#the-edge-case-probe-orchestrateprobe-l497).
+- [Brief grid and pre-check reading](docs/mesures/brief-implementation-enrichi-avant-apres.md): grid of the code-reviewer in the `implement` brief (L523).
 - [docs/deliver.md](docs/deliver.md): wait for the CI, deploy, verify the effect; [docs/remote-gate.md](docs/remote-gate.md): the gate on another machine.
 - [docs/spec.md](docs/spec.md): screen and back-end sheets.
 - [docs/ref.md](docs/ref.md): reference documents (specs, norms, mock-ups) and the coverage of their elements by the lots.
 - [docs/lead.md](docs/lead.md): the lead workflow, and the `livreur` agent that delivers a ready lot for it.
-- [docs/overview.md](docs/overview.md): the longer introduction and the map of every page.
-- [docs/fonctionnement.md](docs/fonctionnement.md): how it all works, in four figures.
+- [docs/overview.md](docs/overview.md): the longer introduction and the map of every page; [docs/fonctionnement.md](docs/fonctionnement.md): how it works.
 - [docs/stabilite.md](docs/stabilite.md): what is guaranteed from 1.0.0; [docs/qualite.md](docs/qualite.md): the code-quality ratchet.
 - [docs/whats-new.md](docs/whats-new.md) and [CHANGELOG.md](CHANGELOG.md): what changed.
 

package/dist/deliver-ci.js

@@ -0,0 +1,105 @@
+import { basename } from 'node:path';
+import { isPlanOnly } from './audit.js';
+import { isAncestor, readCommits } from './git.js';
+import { appendStep, lastDelivery } from './state.js';
+const POLL_CI = 15_000;
+const CI_APPEAR = 300_000;
+const CI_OK = new Set(['success', 'skipped', 'neutral']);
+/** « HH:MM:SS » UTC d'un instant en millisecondes : l'heure qui ouvre chaque ligne d'étape de la sortie. */
+const clockTime = (ms) => new Date(ms).toISOString().slice(11, 19);
+export const stamped = (deps, line) => `${clockTime(deps.now())} ${line}`;
+/**
+ * Livraison précédente quand la CI du sha n'a pas à être attendue : un seul fichier hors plan dans précédente..sha suffit à
+ * l'exiger. Null (CI attendue) sans plan, sans livraison précédente, si elle n'est pas un ancêtre du sha ou l'égale, si elle n'est pas un sha complet (ligne du journal écrite à la main), si la
+ * lecture échoue ou rend aucun commit : on ne saute la CI que sur une preuve (au moins un commit, tous plan seul).
+ */
+export function planOnlySince(ctx, sha) {
+    if (!ctx.plan)
+        return null;
+    const prev = lastDelivery(ctx.state);
+    if (!prev || !/^[0-9a-f]{40,64}$/.test(prev) || prev === sha || !isAncestor(ctx.root, prev, sha))
+        return null;
+    try {
+        const commits = readCommits(ctx.root, { range: `${prev}..${sha}` });
+        return commits.length > 0 && commits.every((c) => isPlanOnly(c.sha, ctx.plan, ctx.root)) ? prev : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Un tour de `gh run list` : message d'échec, null si tous les runs sont verts, undefined tant qu'il faut attendre. */
+function pollOnce(ctx, deps, sha, start, state) {
+    let runs = [];
+    let error = null;
+    try {
+        runs = deps.gh(sha);
+        state.failingSince = null;
+    }
+    catch (e) {
+        // Erreur passagère (réseau, quota d'API) : on réessaie ; persistante, on abandonne avec sa cause.
+        error = e.message;
+        state.failingSince ??= deps.now();
+    }
+    const elapsed = deps.now() - start;
+    if (error !== null) {
+        if (deps.now() - state.failingSince >= CI_APPEAR || elapsed >= ctx.config.ciTimeout * 1000)
+            return `gh run list en échec : ${error}`;
+        ctx.err(`  gh run list en échec, nouvel essai : ${error}`);
+        return undefined;
+    }
+    if (runs.length === 0) {
+        return elapsed >= CI_APPEAR ? `aucun run CI pour ce sha après ${CI_APPEAR / 60_000} min (le commit poussé est-il celui que la CI construit ?)` : undefined;
+    }
+    const pending = runs.filter((r) => r.status !== 'completed');
+    const summary = `${runs.length} run(s), ${runs.length - pending.length} terminé(s)`;
+    if (summary !== state.summary)
+        ctx.out(`  ${summary}`);
+    state.summary = summary;
+    if (pending.length > 0)
+        return undefined;
+    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;
+}
+/** Message d'échec, ou null quand les runs GitHub du sha sont tous verts. */
+export async function pollGithubCi(ctx, deps, sha) {
+    const { ciTimeout } = ctx.config;
+    ctx.out(stamped(deps, `→ CI : attente des runs GitHub de ${sha.slice(0, 7)}`));
+    const start = deps.now();
+    const state = { summary: '', failingSince: null };
+    for (;;) {
+        const verdict = pollOnce(ctx, deps, sha, start, state);
+        if (verdict !== undefined)
+            return verdict;
+        if (deps.now() - start >= ciTimeout * 1000)
+            return `CI non terminée après ${ciTimeout} s`;
+        await deps.sleep(POLL_CI);
+    }
+}
+/**
+ * Journal des étapes (L516) : `step(etape, debut, ok)` ajoute une ligne à `deliveries-steps.log`. Une mesure, jamais bloquante :
+ * une écriture qui échoue est signalée une seule fois, la livraison continue. `lots` n'est lu qu'à la première écriture.
+ */
+export function stepJournal(ctx, deps, sha, lots) {
+    let known = null;
+    let warned = false;
+    return (etape, debut, ok) => {
+        try {
+            const fin = deps.now();
+            appendStep(ctx.state, {
+                lots: (known ??= lots()),
+                sha,
+                projet: ctx.plan?.project || basename(ctx.root),
+                etape,
+                debut: new Date(debut).toISOString(),
+                fin: new Date(fin).toISOString(),
+                duree_s: Math.round((fin - debut) / 1000),
+                resultat: ok ? 'ok' : 'echec',
+            });
+        }
+        catch (e) {
+            if (!warned)
+                ctx.err(`deliver : journal des étapes non écrit : ${e.message}`);
+            warned = true;
+        }
+    };
+}

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?.() ?? []) : [] };
     }

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/briefs.js

@@ -82,6 +82,23 @@ export function localReading(lot) {
         'Keep every read small (`grep -n`, `git log --oneline -S`, a few dozen lines at a time, never a whole large file),',
     ].join('\n');
 }
+/**
+ * Ce que le précheck apporte au brief de l'implémentation : son constat (« partiel ») puis, séparée par une ligne vide, ce qu'il a lu
+ * (L523), pour que la session parte de là au lieu de tout relire à froid. `lu` n'est passé qu'à la première passe : la lecture date du
+ * début du lot, une reprise après interruption a des commits à relire (l'appelant ne le passe pas). Sans constat ni lecture, `commits` est rendu tel quel.
+ */
+export function precheckBrief(commits, finding, lu) {
+    const withFinding = finding ? [commits, finding].filter(Boolean).join('\n') : commits;
+    if (!lu)
+        return withFinding;
+    const reading = [
+        'Pre-check reading (L523): the read-only pre-check of this lot, at the start of the lot, looked in the repository and read this.',
+        'Start from these files, the neighbouring code to imitate and the existing tests it names, without searching for them again;',
+        'reopen a file only to modify it or when this reading is not enough, and re-read the lines you edit (the reading dates from the start of the lot).',
+        lu,
+    ].join('\n');
+    return [withFinding, reading].filter(Boolean).join('\n\n');
+}
 const FILES = {
     precheck: 'precheck.md',
     spec: 'spec.md',
@@ -129,9 +146,9 @@ export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
     return `${out.replace(/[ \t]+\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim()}\n`;
 }
 /**
- * Consigne `{{gate}}` (L399) : le programme rejoue après chaque écriture `orchestrate.test` et `orchestrate.build`, pas la commande que la session juge équivalente.
+ * Consigne `{{gate}}` (L399, L518) : le programme joue une fois après l'écriture `orchestrate.test` et `orchestrate.build` ; la session ne joue que les tests ciblés du code touché (la suite entière rejouée en session coûtait 2,7 suites par lot, étude L517) et le build tel quel, pas la commande qu'elle juge équivalente.
  * Du 22 au 28-10, des lots annoncés verts arrivaient rouges à la porte parce que la session avait joué `npm run build` (tsconfig.build.json : `src` seul)
- * alors que la porte joue `npx tsc --noEmit` (test et scripts compris) : L330, L353. Vide sans commande déclarée.
+ * alors que la porte joue `npx tsc --noEmit` (test et scripts compris) : L330, L353. Vide sans commande déclarée ; sans `orchestrate.test`, la session joue elle-même la suite complète, une fois.
  */
 export function gateText(gate) {
     // Porte en parties (L512) : une ligne par partie, avec son dossier, jamais la liste sérialisée.
@@ -139,7 +156,10 @@ export function gateText(gate) {
     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.`;
+    // Sans `orchestrate.test`, le programme ne joue aucune suite (runChecks la saute) : la session est la seule à pouvoir la jouer.
+    if (!gate.test)
+        return `The program's gate, played once by the program after your writing session, is exactly:\n${lines.join('\n')}\nThe program plays no test suite for this project: play the full suite yourself, once, before committing, and the build command as written, not a narrower one (\`npm run build\` may cover less than the gate). A red at the gate sends the lot back to a correction pass even when your own run was green.`;
+    return `The program's gate, played once by the program after your writing session, is exactly:\n${lines.join('\n')}\nPlay only the tests of the code you touch (targeted: one file or filter, never the full suite), once, before committing: the full suite is not yours to replay (L518). Play the build command as written, not a narrower one (\`npm run build\` may cover less than the gate). A red at the gate sends the lot back to a correction pass even when your own run was green.`;
 }
 /**
  * L'objectif d'un lot (L258) : celui gardé dans l'état du lot (`LotState.goal`, fixé au lancement : `--goal`, sinon la clé `goal:` du plan),