@sylad/cadence 1.35.0 → 1.36.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.36.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.36.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

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)));