@sylad/cadence 1.9.0 → 1.10.0

package/dist/orchestrate/cycle.js

@@ -16,7 +16,8 @@ import { isOpen } from '../plan.js';
 import { isPlanOnly } from '../audit.js';
 import { compareBaseline, failedTests, hasUnnamedFailure } from './baseline.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
-import { capturesText, headline, integrationText, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, tmpText } from './briefs.js';
+import { capturesText, headline, integrationText, localReading, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, tmpText } from './briefs.js';
+import { SlotAbandoned } from './registry.js';
 import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, trackGroup, writeMcpConfig } from './launch.js';
 import { cleanPlaywrightOutput, pushed, snapshot } from './guard.js';
 import { sumTokens } from './result.js';
@@ -27,7 +28,7 @@ import { avalFicheText, ficheContracts, ficheRules, hasScreenPart } from './aval
 import { ficheReviewText, reviewedSheetText } from './fiche.js';
 import { bulletLines, maquetteText, reviewedText } from './maquette.js';
 import { answeredText, checkSpec, costlyHypotheses, ficheHasBack, ficheReady, findFiche, hypothesisLines, answerAltersRule, hypothesisNote, LEAD_SOURCE, ruleIdsSourcedByLead, sourceRules, specText } from './spec.js';
-import { PRECHECK_UNREADABLE, lotKey, lotRepoPaths, neighbourDirs } from './state.js';
+import { LOCAL_PRECHECK_UNREADABLE, PRECHECK_UNREADABLE, lotKey, lotRepoPaths, neighbourDirs } from './state.js';
 import { advance, INTEGRATE_WAIT_MS, mergeBase, patchId, rebaseOnto, repoBranch, takeRepoWrite } from './integrate.js';
 import { mutexFor } from './mutex.js';
 import { branchExists, git, gitFailure, integrated, linkIgnored, lotBranch, planFileSet, planSeenFrom, prepareTree, removeTree, trackedDirty } from './worktree.js';
@@ -136,6 +137,10 @@ async function baselineFailures(c, command) {
     try {
         git(l.repo, 'worktree', 'add', '--detach', '-f', dir, sha);
         links.push(...linkIgnored(l.repo, dir));
+        // Le build d'abord, comme dans la porte (L333) : les tests lisent ce qu'il produit (`dist`), le départ sans lui rougirait tout. Un build rouge au départ
+        // ne dit rien des tests : pas de ligne de base, l'appelant garde les tests pour rouges.
+        if (c.config.build && (await sh(c, c.config.build, 30 * 60_000, {}, dir)).code !== 0)
+            return null;
         const r = await sh(c, command, 30 * 60_000, {}, dir);
         const failures = r.code === 0 ? [] : failedTests(r.output);
         l.baseline = { sha, command, failures, verified: true };
@@ -293,10 +298,19 @@ function checksText(c) {
 }
 /** La clé `docs` du cadence.yaml du projet de ce lot. */
 const docsConfig = (c) => readDocsConfig(histPlan(c).configFile ?? join(wd(c), 'cadence.yaml'));
-/** Écarts docs.sync des commits du lot (L143), calculés au moment de la demande : ni gardés ni écrits d'avance. */
+/** Écarts docs.sync des commits du lot (L143), calculés au moment de la demande : ni gardés ni écrits d'avance. Un écart acquitté et motivé (`raf docs-ok`, L317) n'en est plus un. */
 function docGaps(c) {
     const { sync } = docsConfig(c);
-    return { sync, gaps: sync.length ? docSyncGaps(sync, filesOf(wd(c), lotWork(histPlan(c), wd(c), c.lot.lot))) : [] };
+    const plan = histPlan(c);
+    const acknowledged = !!plan.lots().find((x) => x.id === c.lot.lot)?.docsOk;
+    return { sync, gaps: sync.length && !acknowledged ? docSyncGaps(sync, filesOf(wd(c), lotWork(plan, wd(c), c.lot.lot))) : [] };
+}
+/** Cause du renvoi au lead d'un lot dont l'écart docs.sync est ouvert (L317), null sans écart. */
+function openDocGap(c) {
+    const { gaps } = docGaps(c);
+    if (!gaps.length)
+        return null;
+    return `documentation en retard (docs.sync) : ${gaps.flatMap((g) => g.touched).join(', ')} sans la documentation attendue, et aucun écart acquitté — écrire la documentation, ou \`raf docs-ok ${c.lot.lot} --reason "…"\` si elle reste vraie`;
 }
 /** Consigne docs.sync du brief de revue (L143). */
 function docsText(c) {
@@ -384,7 +398,7 @@ function avalOf(c, kind) {
     // la revue courte d'un petit lot visible est sa seule passe : elle porte aussi la conformité à la maquette
     return kind === 'review-small' && l.small && l.visible && screen ? `${text}\n${avalFicheText('ux', o)}` : text;
 }
-function briefFor(c, kind) {
+function briefFor(c, kind, local = false) {
     const plan = c.loadPlan();
     const l = c.lot;
     const lot = plan.lot(l.lot);
@@ -398,6 +412,8 @@ function briefFor(c, kind) {
     if (mcpServersFor(kind, l.visible, '', l.small, !!l.screen).playwright)
         vars.shots = shotsText(playwrightDir(c.wave.store.lotDir(l.project, l.lot)));
     vars.fiche = hasSpecStage(l) ? avalOf(c, kind) : '';
+    if (kind === 'precheck' && local)
+        vars.lecture = localReading({ ...lot, goal: l.goal ?? lot.goal });
     if (kind === 'spec') {
         const reviewed = [...(l.ficheConstats ?? []), ...(l.maquetteConstats ?? [])];
         const written = ficheOf(c);
@@ -441,8 +457,12 @@ function briefFor(c, kind) {
         if (kind === 'fix') {
             vars.commits = lotCommitLines(c);
             vars.constats = constatLines(l.constats);
-            if (l.docsFix)
+            if (l.docsFix) {
                 vars.elsewhere = articlesBrief(l.repo, docsConfig(c).articles ?? []);
+                vars.ack = wd(c) === l.repo
+                    ? `run \`raf docs-ok ${l.lot} --reason "why the documentation stays true"\` (a reason is required), then commit the plan file alone (\`git add -- .cadence/raf.yaml\`, or the path of the plan; message \`chore(${l.lot}): docs-ok\`).`
+                    : `this is a worktree, where only the program writes the plan: do not run \`raf docs-ok\` and do not touch the plan file. Make no commit and say under "choix" why the documentation stays true: the lot is handed back to the lead, who acknowledges it in the main checkout (\`raf docs-ok ${l.lot} --reason "…"\`).`;
+            }
         }
         else if (interrupted) {
             const mine = lotCommitLines(c);
@@ -493,6 +513,8 @@ export const STOP_REQUESTED = 'arrêt demandé (--stop-after-current)';
 /** Le lot a-t-il été écarté de la vague par `--drop` (L79) ? */
 const dropped = (c) => c.wave.store.control().drops.includes(lotKey(c.lot.project, c.lot.lot));
 export const DROPPED = 'retiré de la vague (--drop)';
+/** Mention de la réponse du lead restée en attente : un lot rendu sans que la session l'ait lue le dit (comme overBudget). */
+const unplayedAnswer = (l) => (l.pendingAnswer ? ` ; la réponse du lead (« ${l.pendingAnswer} ») n'a pas été jouée` : '');
 /** Pourquoi plus aucune session ne doit partir (incident, quota, budget), sinon null. */
 function halted(w, lot) {
     if (w.store.control().stopAfterCurrent)
@@ -519,14 +541,17 @@ function reviewModel(c, kind) {
     const { light, full } = c.config.review;
     return c.lot.light && c.lot.pass === 0 && (kind === 'review' || kind === 'review-small') ? light : full;
 }
-/** Une session : budget et quota vérifiés avant, état écrit avant et après, journal gardé, contrôles du dépôt après. */
+/** Écarte le modèle local pour le reste de la vague (L322) : le premier échec suffit, les lots suivants n'attendent pas de le constater à leur tour. */
+function benchLocal(c, cause) {
+    c.wave.localOut ??= cause.slice(0, 200);
+}
 /** Rendu par `session(…, true)` quand l'étape locale n'a rien donné (Ollama éteint, délai, rapport sans structure) : l'appelant se replie sur Sonnet (L146). */
 const LOCAL_FAILED = Symbol('local-failed');
 async function session(c, kind, local = false) {
     const w = c.wave;
     const l = c.lot;
     if (dropped(c))
-        return stop(c, 'handed-back', DROPPED);
+        return stop(c, 'handed-back', DROPPED + unplayedAnswer(l));
     const halt = halted(w, l);
     if (halt)
         return suspend(c, halt);
@@ -548,7 +573,7 @@ async function session(c, kind, local = false) {
     w.log(`${lotKey(l.project, l.lot)} · session ${n} ${kind} (${model})`);
     let brief;
     try {
-        brief = briefFor(c, kind);
+        brief = briefFor(c, kind, local);
     }
     catch (e) {
         step.status = 'failed';
@@ -559,6 +584,7 @@ async function session(c, kind, local = false) {
     const playwright = !!mcpServersFor(kind, l.visible, '', l.small, !!l.screen).playwright;
     if (playwright)
         l.uxCaptures = join(dirname(mcpConfig), 'playwright');
+    const answerInBrief = l.pendingAnswer; // gardée pour la rendre si la session ne part jamais (créneau abandonné, L332)
     l.pendingAnswer = null; // la réponse est dans le brief : elle ne repart pas avec la session suivante
     const tmpDir = w.store.tmpDir(l.project, l.lot); // TMPDIR de la session, aussi en --add-dir : hors du cwd, un Write y serait refusé en `claude -p`
     // Délai (L298) : l'étape d'écriture est proportionnée à l'estimate et à la fiche du lot, puis prolongée à chaque échéance où elle a commité.
@@ -617,7 +643,55 @@ async function session(c, kind, local = false) {
             step.sessionId = id;
             save(c);
         },
+    }).catch((e) => {
+        if (e instanceof SlotAbandoned)
+            return e;
+        throw e;
     });
+    if (outcome instanceof SlotAbandoned) {
+        // L332 : la demande est arrivée pendant l'attente d'un créneau. Une étape qui n'a pas démarré (aucun pid) n'a pas eu lieu : elle ne figure pas à l'état.
+        // Rien de ce que le brief a consommé n'a servi : la réponse du lead (retirée de pendingAnswer avant le lancement) revient, la reprise rejoue l'étape avec elle.
+        if (step.pid === undefined) {
+            l.steps.pop();
+            l.pendingAnswer = answerInBrief;
+        }
+        else {
+            // Une session de l'étape a déjà tourné (le pid est le sien) et c'est son lancement SUIVANT qui attendait un créneau (relance d'une session coupée, relance de mise en forme) :
+            // sa sortie, son identifiant et ses jetons sont gardés, la cause dit ce qui n'a pas eu lieu.
+            const dir = w.store.lotDir(l.project, l.lot);
+            const base = `${n}-${kind}`;
+            const after = outcome.after;
+            const spentOf = (sessionId) => (w.claudeHome ? (journalTokens(w.claudeHome, wd(c), sessionId)?.tokens ?? null) : null);
+            let tokens = null;
+            let cause = outcome.message;
+            if (after?.relaunched) {
+                const cutRun = after.relaunched;
+                tokens = spentOf(cutRun.sessionId);
+                step.sessionId = cutRun.sessionId; // la session neuve n'a jamais démarré : l'étape est celle de la session coupée
+                writeFileSync(join(dir, `${base}.first.err`), cutRun.stderr);
+                cause = `coupée (${cutRun.cause}), relance en session neuve non faite : ${outcome.message}`;
+                l.warnings.push(`${kind} coupée (${cutRun.cause}) : sa relance en session neuve n'a pas eu lieu, ${outcome.message}`);
+            }
+            else if (after?.formatting) {
+                const first = after.formatting;
+                tokens = first.tokens ?? (first.sessionId ? spentOf(first.sessionId) : null);
+                if (first.sessionId)
+                    step.sessionId = first.sessionId;
+                writeFileSync(join(dir, `${base}.first.json`), first.stdout);
+                writeFileSync(join(dir, `${base}.first.err`), first.stderr);
+                cause = `sortie sans structured_output, relance de mise en forme non faite : ${outcome.message}`;
+            }
+            if (tokens && !local) {
+                step.tokens = tokens;
+                w.budget.add(tokens);
+            }
+            step.status = 'failed';
+            step.cause = cause;
+            step.ended = new Date().toISOString();
+            w.saveWave();
+        }
+        return outcome.reason === DROPPED ? stop(c, 'handed-back', DROPPED + unplayedAnswer(l)) : suspend(c, outcome.reason);
+    }
     step.ended = new Date().toISOString();
     const dir = w.store.lotDir(l.project, l.lot);
     const base = `${n}-${kind}`;
@@ -655,7 +729,9 @@ async function session(c, kind, local = false) {
     }
     if (local && outcome.kind !== 'ok') {
         // Hors quota Anthropic : rien au budget (ni sortie, ni journal), et jamais d'arrêt du lot — Sonnet reprend le contrôle.
-        const cause = outcome.kind === 'failed' ? outcome.cause : outcome.message;
+        // Un appel d'outil écrit en texte (`<function=Bash>`) est une sortie sans structured_output : le local n'a pas tenu l'appel d'outils, inutile d'attendre un second tour.
+        const textCall = outcome.kind === 'failed' && outcome.stdout.includes('<function=');
+        const cause = textCall ? 'appel d\'outil écrit en texte, pas de structured_output' : outcome.kind === 'failed' ? outcome.cause : outcome.message;
         writeFileSync(join(dir, `${base}.json`), outcome.kind === 'failed' ? outcome.stdout : '');
         if (outcome.kind === 'failed')
             writeFileSync(join(dir, `${base}.err`), outcome.stderr);
@@ -664,6 +740,7 @@ async function session(c, kind, local = false) {
         step.report = `${base}.json`;
         delete step.tokens;
         l.warnings.push(`contrôle préalable : modèle local sans résultat (${cause.slice(0, 200)}), repli sur Sonnet`);
+        benchLocal(c, cause);
         save(c);
         return LOCAL_FAILED;
     }
@@ -944,9 +1021,9 @@ function overBudget(c, reserve = false) {
     const why = reserve ? `budget du lot : ${lotSpent(l)} / ${l.budget} tokens comptés (${basis}), il ne reste pas de quoi payer la correction et la revue courte qui la suivrait (${REVIEW_RESERVE} réservés)` : `budget du lot atteint (${lotSpent(l)} / ${l.budget} tokens comptés, ${basis})`;
     // Tests rouges après une écriture : la passe fix refusée aurait suivi, le lot revient sans revue (L145) — la cause le dit.
     const red = l.next === 'fix' && l.constats.some((k) => k.source === 'tests');
-    // Passe d'écriture qui vient d'être jouée, nommée d'après le compteur : l.pass - 1 passes de correction l'ont précédée (minorPass reste vrai après la passe des mineurs).
+    // Passe d'écriture qui vient d'être jouée, nommée d'après le compteur : l.pass - 1 passes de correction l'ont précédée (minorPass reste vrai après la passe des mineurs). Sans passe jouée, un lot repris déjà revu compte ses tests rouges depuis la revue de sa branche ; jamais revu (L315), c'est l'implémentation qui les a laissés.
     const played = l.pass - 1;
-    const after = l.minorPass && played === (l.minorPassAt ?? 0) ? 'la passe des mineurs' : played > 0 ? `la passe fix ${played}` : "l'implémentation";
+    const after = l.minorPass && played === (l.minorPassAt ?? 0) ? 'la passe des mineurs' : played > 0 ? `la passe fix ${played}` : l.resumedFrom && l.resumedReviewed ? 'la dernière revue de la branche reprise' : "l'implémentation";
     const notPlayed = l.next === 'fix' ? 'correction non jouée (budget) : ' : '';
     const prefix = notPlayed + (red ? `tests rouges après ${after}, correction suivante non abordable : ` : '');
     const unreviewed = red ? ' ; le lot revient sans revue, avec ses constats' : '';
@@ -1001,18 +1078,28 @@ const CITES_FINDING = /(?<![\w-])(?:constat\w*|revues?|reviews?|audits?)(?![\w-]
 function citesPriorWork(text, lot, ids) {
     if (CITES_FINDING.test(text))
         return true;
-    if (/(?<![\w-])[a-z][\w-]*:L\d+(?!\w)/i.test(text))
-        return true;
+    const { ids: cited, foreign } = citedLots(text, lot, ids);
+    return foreign || cited.length > 0;
+}
+/**
+ * Les lots que le texte cite (même reconnaissance que `citesPriorWork`, L288/L292) : les identifiants du plan cités, et `foreign` quand il cite un lot d'un autre projet
+ * (`cadence:L68`, dont on ne lit pas les commits ici).
+ */
+function citedLots(text, lot, ids) {
+    const foreign = /(?<![\w-])[a-z][\w-]*:L\d+(?!\w)/i.test(text);
     const own = /^L(\d+)$/.exec(lot);
     const cited = (id) => new RegExp(`(?<![\\w.-])${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![\\w-]|\\.\\w)`).test(text);
-    return ids.some((id) => {
-        if (id === lot)
-            return false;
-        const n = /^L(\d+)$/.exec(id);
-        if (own && n)
-            return Number(n[1]) < Number(own[1]) && new RegExp(`(?<![\\w-])${id}(?!\\w)`).test(text);
-        return cited(id);
-    });
+    return {
+        foreign,
+        ids: ids.filter((id) => {
+            if (id === lot)
+                return false;
+            const n = /^L(\d+)$/.exec(id);
+            if (own && n)
+                return Number(n[1]) < Number(own[1]) && new RegExp(`(?<![\\w-])${id}(?!\\w)`).test(text);
+            return cited(id);
+        }),
+    };
 }
 /**
  * Le contrôle préalable ne vaut que pour un lot sans commit (avec des commits, l'implémentation reprend légitimement) dont le
@@ -1030,6 +1117,44 @@ export function needsPrecheck(config, plan, repo, lot, repos = [], goal) {
     const text = [l.title, l.goal, goal].filter(Boolean).join('\n');
     return citesPriorWork(text, lot, plan.lots().map((x) => x.id));
 }
+/**
+ * Un lot créé après le dernier commit de code du dépôt n'a rien à retrouver (L322) : tout ce que le dépôt contient date d'avant le lot, donc aucun autre lot ne l'a livré.
+ * Rend la raison à écrire au journal, ou null quand le contrôle garde un sens. Le lot est daté par le commit qui a ajouté son id au plan, borné par sa clé `created` (une
+ * migration ou un déplacement du plan ne rajeunit pas un vieux lot) ; le dernier commit de code est le dernier qui ne touche pas que le plan (`isPlanOnly`). Prudent : lot
+ * qui travaille dans des dépôts voisins, id introuvable dans l'historique du plan, dépôt sans commit de code ou instants égaux → le contrôle reste.
+ * Le contrôle reste aussi quand le titre ou le goal (ou le goal donné au lancement) cite un lot qui a déjà ses propres commits, ou un lot d'un autre projet : une « suite de revue L<n> » écrite
+ * juste après le dernier correctif de L<n> liste des constats que les passes de correction de L<n> ont pu régler avant la création du lot (rejoué depuis le 24-10 : 5 lots sautés à tort,
+ * dont 2 avec un vrai « partiel »).
+ */
+export function precheckNothingToFind(plan, root, lot, repos = [], goal) {
+    if (repos.length)
+        return null;
+    try {
+        const rel = relative(root, plan.path);
+        const idLine = `^\\s*- id: ["']?${lot.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&')}["']?\\s*$`;
+        // Pas de `--reverse` : avec `--follow`, git 2.43 ne rend rien sur un fichier renommé (`raf migrate`) ; le plus ancien est la dernière ligne.
+        const added = git(root, '-c', 'core.quotepath=off', 'log', '--follow', '--format=%ct', '-G', idLine, '--', rel).split('\n').filter(Boolean).pop();
+        if (!added)
+            return null;
+        const created = plan.lot(lot).created;
+        const endOfCreated = created ? Date.parse(`${created}T23:59:59`) / 1000 : Infinity;
+        const createdAt = Math.min(Number(added), Number.isNaN(endOfCreated) ? Infinity : endOfCreated);
+        const log = git(root, 'log', '--format=%H %ct').split('\n').filter(Boolean);
+        const code = log.map((x) => x.split(' ')).find(([sha]) => !isPlanOnly(sha, plan, root));
+        if (!code)
+            return null;
+        if (createdAt <= Number(code[1]))
+            return null;
+        const l = plan.lot(lot);
+        const { ids, foreign } = citedLots([l.title, l.goal, goal].filter(Boolean).join('\n'), lot, plan.lots().map((x) => x.id));
+        if (foreign || ids.some((id) => lotWork(plan, root, id).length > 0))
+            return null;
+        return `lot créé après le dernier commit de code du dépôt (${code[0].slice(0, 7)}) : rien à retrouver`;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Contrôle préalable (L77) : une session de lecture seule cherche si le livrable du lot est déjà dans le dépôt (fait par un
  * autre lot). « oui » rend le lot sans ouvrir d'implémentation ; « partiel » joint le constat au brief de l'implémentation.
@@ -1039,7 +1164,10 @@ async function precheck(c) {
     const l = c.lot;
     let rep = null;
     let localYes = false;
-    if (c.config.precheckLocal) {
+    if (c.config.precheckLocal && c.wave.localOut) {
+        l.warnings.push(`contrôle préalable : modèle local écarté pour la vague (${c.wave.localOut}), Sonnet directement`);
+    }
+    else if (c.config.precheckLocal) {
         // Modèle local (L146) : un échec, un rapport illisible ou un « oui » (qui rendrait le lot sans implémentation) rend la main à Sonnet.
         const done = await session(c, 'precheck', true);
         if (!done)
@@ -1049,7 +1177,8 @@ async function precheck(c) {
                 rep = checkShape(done.report, PRECHECK_SCHEMA);
             }
             catch (e) {
-                l.warnings.push(`contrôle préalable : rapport du modèle local illisible (${e.message}), repli sur Sonnet`);
+                l.warnings.push(`${LOCAL_PRECHECK_UNREADABLE} (${e.message}), repli sur Sonnet`);
+                benchLocal(c, `rapport illisible : ${e.message}`);
             }
             if (rep?.dejaPresent === 'oui') {
                 localYes = true;
@@ -1093,6 +1222,16 @@ async function precheck(c) {
     l.next = firstWrite(c);
     save(c);
 }
+/** Le lot passe-t-il par le contrôle préalable ? Un lot qui n'a rien à retrouver (L322) saute l'étape, et le journal du lot le dit. */
+function precheckOrSkip(c) {
+    const plan = c.loadPlan();
+    if (!needsPrecheck(c.config, plan, c.lot.repo, c.lot.lot, c.lot.repos, c.lot.goal))
+        return false;
+    const nothing = precheckNothingToFind(histPlan(c), wd(c), c.lot.lot, c.lot.repos, c.lot.goal);
+    if (nothing)
+        c.lot.warnings.push(`contrôle préalable sauté : ${nothing}`);
+    return !nothing;
+}
 /** Première session d'écriture d'un lot : la spec quand il déclare `screen:` ou `spec: true` et qu'aucune fiche n'est écrite, sinon l'implémentation. */
 function firstWrite(c) {
     const l = c.lot;
@@ -1671,12 +1810,12 @@ async function acceptGreen(c) {
     return null;
 }
 /**
- * Les contrôles du programme (`orchestrate.test` puis `orchestrate.build`), joués dans `wd(c)` : chaque résultat est ajouté à `runs`, chaque rouge NOUVEAU à `red`
- * (un test déjà rouge au sha de départ n'en est pas un, L213). S'arrête au premier rouge. Après une écriture (work) et, au sommet rebasé, avant l'avance de la branche du dépôt (R7).
+ * Les contrôles du programme (`orchestrate.build` puis `orchestrate.test`, L333 : les tests e2e lisent le `dist` que seul le build produit), joués dans `wd(c)` : chaque résultat est ajouté à `runs`, chaque rouge NOUVEAU à `red`
+ * (un test déjà rouge au sha de départ n'en est pas un, L213). S'arrête au premier rouge : un build rouge rend le lot sans lancer les tests. Après une écriture (work) et, au sommet rebasé, avant l'avance de la branche du dépôt (R7).
  */
 async function programChecks(c, red, runs) {
     const l = c.lot;
-    for (const [label, command] of [['tests', c.config.test], ['build', c.config.build]]) {
+    for (const [label, command] of [['build', c.config.build], ['tests', c.config.test]]) {
         if (!command)
             continue;
         const r = await sh(c, command);
@@ -1700,6 +1839,37 @@ async function programChecks(c, red, runs) {
         return;
     }
 }
+/**
+ * Contrôles du sommet intégré (L328) : un rouge est relancé une fois avant de rendre le lot. Le 25-10, L326 a été rendu pour un rouge de charge (L325 tournait en même
+ * temps) alors que le même sommet rejoué seul était vert. Rouge deux fois = rendu, avec le résultat de la seconde passe ; vert à la relance = une alerte sur le lot et une ligne du journal.
+ */
+async function integratedChecks(c, key) {
+    const first = [];
+    let runs = [];
+    await programChecks(c, first, runs);
+    if (!first.length)
+        return { red: first, runs };
+    c.wave.log(`${key} tests rouges au sommet intégré, relancés une fois (${first.map(redExcerpt).join(' ; ')})`);
+    const red = [];
+    runs = [];
+    await programChecks(c, red, runs);
+    if (!red.length)
+        c.lot.warnings.push(`rouge au sommet intégré, vert à la relance (charge de la machine ?) : ${first.map(redExcerpt).join(' ; ')}`);
+    return { red, runs };
+}
+const EXCERPT_LINES = 10;
+/**
+ * Le constat rouge d'un contrôle, en une ligne pour le motif d'un refus (L328) : la commande, puis les tests rouges nommés quand le constat les liste (« - nom »),
+ * sinon la fin de la sortie. La première ligne seule laissait « npx vitest run en échec (code 1) : » sans un nom de test.
+ */
+export function redExcerpt(k) {
+    const [head, ...rest] = k.texte.split('\n');
+    const lines = rest.map((x) => x.trim()).filter(Boolean);
+    const named = lines.filter((x) => x.startsWith('- '));
+    const shown = named.length ? named.slice(0, EXCERPT_LINES) : lines.slice(-EXCERPT_LINES);
+    const more = named.length > EXCERPT_LINES ? [`… (+${named.length - EXCERPT_LINES})`] : [];
+    return [head.replace(/\s*:$/, ''), ...shown, ...more].join(' ; ');
+}
 /** Étape d'écriture (implémentation, correction) : contrôles, puis étape suivante décidée. */
 async function work(c, kind) {
     const l = c.lot;
@@ -1790,13 +1960,13 @@ async function work(c, kind) {
     }
     // Reprise : une session précédente de l'étape (correction ordinaire ou passe des mineurs) a pu commiter avant d'être coupée ; la revue d'origine ne vaut alors plus.
     // Référence : le HEAD de départ de la première session coupée de la série qui précède celle-ci (pas la revue, qui peut ne pas exister encore).
-    let resumedFrom;
+    let interruptedAt;
     for (const s of l.steps.slice(0, -1).reverse()) {
         if (s.kind !== 'fix' || s.status !== 'interrupted')
             break;
-        resumedFrom = s.headBefore;
+        interruptedAt = s.headBefore;
     }
-    const headMoved = kind === 'fix' && made === 0 && !!resumedFrom && git(wd(c), 'rev-parse', 'HEAD') !== resumedFrom;
+    const headMoved = kind === 'fix' && made === 0 && !!interruptedAt && git(wd(c), 'rev-parse', 'HEAD') !== interruptedAt;
     if (minorsPass && made === 0 && !headMoved) {
         // Rien à corriger (mineurs jugés faux, listés en « choix ») : la revue conforme d'origine vaut, HEAD n'a pas bougé.
         for (const k of l.constats.filter((k) => k.gravite === 'mineur'))
@@ -1821,6 +1991,14 @@ async function work(c, kind) {
         stop(c, 'handed-back', `${kind} sans commit`);
         return;
     }
+    // L317 : la passe du bibliothécaire qui laisse l'écart ouvert (rien commité, ou autre chose que la documentation) ne passe pas à la revue : le lot ne finirait pas prêt, `raf check` resterait rouge.
+    if (docsPass) {
+        const open = openDocGap(c);
+        if (open) {
+            stop(c, 'handed-back', open);
+            return;
+        }
+    }
     if (headMoved)
         l.warnings.push(`${minorsPass ? 'passe des mineurs' : 'correction'} reprise sans nouveau commit : un commit d'une session précédente est relu par la revue`);
     else if (made === 0)
@@ -2107,6 +2285,12 @@ async function conclude(c, code, minorNote = '') {
     const verdict = `${code.verdict} — orchestré (vague ${c.wave.id}, ${l.pass} passe(s) de correction${l.minorPass ? ` + passe des mineurs${minorNote}` : ''}${read})`;
     l.verdict = verdict;
     const newer = lotWork(plan, wd(c), l.lot)[0]?.sha ?? null;
+    // L317 : la porte du bibliothécaire peut ne pas avoir été jouée (passes ou budget épuisés) ; un écart docs.sync ouvert ne finit jamais prêt.
+    const gap = openDocGap(c);
+    if (gap) {
+        stop(c, 'handed-back', gap);
+        return;
+    }
     const moved = (code.head && newer !== null && git(wd(c), 'rev-parse', 'HEAD') !== code.head ? [''] : []).concat(neighbours.filter((r) => shas[r.rel] !== null && code.repoHeads?.[r.rel] && git(r.path, 'rev-parse', 'HEAD') !== code.repoHeads[r.rel]).map((r) => ` dans ${r.rel}`));
     if (moved.length) {
         stop(c, 'handed-back', `un commit est postérieur à la revue${moved.join(',')} : verdict non enregistré`);
@@ -2286,16 +2470,16 @@ async function integrateLot(c) {
             if (rebased.kind === 'conflict') {
                 return refuse(`intégration impossible : conflit en rebasant ${t.branch} sur ${t.base}${rebased.files.length ? ` (fichiers : ${rebased.files.join(', ')})` : ` (${rebased.detail})`} ; ${kept}`);
             }
+            if (rebased.kind === 'rebased' && rebased.changelog > 0)
+                c.wave.log(`${key} CHANGELOG.md : conflit d'ajout pur résolu par union sous [Unreleased] (${rebased.changelog} commit(s))`);
             const tip = git(t.dir, 'rev-parse', 'HEAD');
             if (tip !== reviewed) {
                 // Le rebase a changé les commits : tests et build rejoués au sommet rebasé, avant que la branche du dépôt ne bouge (R7).
-                const red = [];
-                const runs = [];
-                await programChecks(c, red, runs);
+                const { red, runs } = await integratedChecks(c, key);
                 l.checks = runs.length ? { head: tip, runs } : undefined;
                 save(c);
                 if (red.length)
-                    return refuse(`intégration refusée : tests rouges au sommet intégré (${red.map((k) => k.texte.split('\n')[0]).join(' ; ')}) ; branche du dépôt inchangée, ${kept}`);
+                    return refuse(`intégration refusée : tests rouges au sommet intégré (${red.map(redExcerpt).join(' ; ')}) ; branche du dépôt inchangée, ${kept}`);
                 const before = patchId(t.dir, mergeBase(t.dir, reviewed, t.base), reviewed);
                 const after = patchId(t.dir, t.base, 'HEAD');
                 if (before !== '' && before === after) {
@@ -2500,8 +2684,14 @@ export async function runLot(c) {
             if (!(await ensureTree(c)))
                 return;
             l.startedSha = (await snapshot(wd(c), { remote: false })).head ?? undefined;
-            l.next = needsPrecheck(c.config, c.loadPlan(), l.repo, l.lot, l.repos, l.goal) ? 'precheck' : firstWrite(c);
-            save(c);
+            // Un lot repris de sa branche conservée (L311) n'a rien à faire contrôler : ses commits sont les siens. Il repart à la correction des constats de sa dernière revue, à la revue s'il en a passé une sans constat, à l'écriture s'il n'a jamais été revu.
+            // La correction de départ est une passe comme les autres (toFix : l.pass, verdict, tableau, MAX_PASSES bornent le total, reprise comprise).
+            if (l.resumedFrom && l.constats.length)
+                toFix(c, l.constats, 'reprise de la branche');
+            else {
+                l.next = l.resumedFrom ? (l.resumedReviewed ? firstReview(c) : firstWrite(c)) : precheckOrSkip(c) ? 'precheck' : firstWrite(c);
+                save(c);
+            }
         }
         while (l.next && !TERMINAL.has(l.status)) {
             const kind = l.next;

package/dist/orchestrate/integrate.js

@@ -1,8 +1,10 @@
 import { execFileSync } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { gitCommonDir } from '../git.js';
 import { sharedStateDir } from '../state.js';
 import { activeLock, releaseLock, takeLock } from './lock.js';
+import { mergeUnreleased } from './changelog-merge.js';
 import { mutexFor } from './mutex.js';
 import { git, gitFailure, tryGit } from './worktree.js';
 /** Verrou d'intégration d'un dépôt (L279, R10) : dans l'état commun aux worktrees, au format du verrou d'orchestration, sous un autre nom. */
@@ -50,24 +52,66 @@ export async function takeRepoWrite(repo, who, o = {}) {
 export const repoBranch = (repo) => tryGit(repo, 'symbolic-ref', '--short', '-q', 'HEAD') || null;
 /** Point de départ de `rev` par rapport à la branche `base` : le dernier ancêtre commun. */
 export const mergeBase = (cwd, rev, base) => git(cwd, 'merge-base', rev, `refs/heads/${base}`);
+const CHANGELOG = 'CHANGELOG.md';
+const REBASE_ENV = { ...process.env, GIT_EDITOR: 'true', GIT_SEQUENCE_EDITOR: 'true' };
+const run = (cwd, ...args) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], env: REBASE_ENV });
+/**
+ * Résout le conflit en cours quand c'est le CHANGELOG seul et de l'ajout pur sous `[Unreleased]` (L314) : écrit l'union, l'ajoute à l'index. Faux, sans rien
+ * toucher, pour tout autre conflit (un autre fichier avec lui, une entrée de base modifiée, une étape de base absente). `start` : le CHANGELOG au point de
+ * départ de la branche (L323), pour qu'un commit puisse réécrire l'entrée qu'un commit précédent du lot a ajoutée.
+ */
+function resolveChangelog(work, start) {
+    const files = (tryGit(work, 'diff', '--name-only', '--diff-filter=U') ?? '').split('\n').filter(Boolean);
+    if (files.length !== 1 || files[0] !== CHANGELOG)
+        return false;
+    try {
+        // Pendant un rebase, l'étape 2 est la branche du dépôt (« ours »), l'étape 3 le commit du lot rejoué (« theirs »).
+        const merged = mergeUnreleased(run(work, 'show', `:1:${CHANGELOG}`), run(work, 'show', `:2:${CHANGELOG}`), run(work, 'show', `:3:${CHANGELOG}`), start);
+        if (merged === null)
+            return false;
+        writeFileSync(join(work, CHANGELOG), merged);
+        run(work, 'add', '--', CHANGELOG);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Rebase le worktree `work` sur la branche `base` (R6). Une branche qui descend déjà du sommet de `base` n'a rien à rebaser (fast-forward pur : aucun sha ne
- * change). Un conflit — ou tout autre échec du rebase — est abandonné (`rebase --abort`) : la branche du lot et son arbre restent tels qu'avant, la
- * branche du dépôt n'a pas été touchée, personne ne résout le conflit à l'aveugle.
+ * change). Un conflit d'ajout pur dans le CHANGELOG est résolu par union à chaque commit qui le porte (L314, `changelog` les compte). Tout autre conflit — ou
+ * tout autre échec du rebase — est abandonné (`rebase --abort`) : la branche du lot et son arbre restent tels qu'avant, la branche du dépôt n'a pas été
+ * touchée, personne ne résout le conflit à l'aveugle.
  */
 export function rebaseOnto(work, base) {
     const before = git(work, 'rev-parse', 'HEAD');
     if (tryGit(work, 'merge-base', '--is-ancestor', `refs/heads/${base}`, 'HEAD') !== null)
         return { kind: 'forwarded' };
+    let changelog = 0;
+    const start = tryGit(work, 'show', `${mergeBase(work, 'HEAD', base)}:${CHANGELOG}`) ?? undefined;
     try {
-        execFileSync('git', ['rebase', `refs/heads/${base}`], { cwd: work, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, GIT_EDITOR: 'true', GIT_SEQUENCE_EDITOR: 'true' } });
+        run(work, 'rebase', `refs/heads/${base}`);
     }
-    catch (e) {
-        const files = (tryGit(work, 'diff', '--name-only', '--diff-filter=U') ?? '').split('\n').filter(Boolean);
-        tryGit(work, 'rebase', '--abort');
-        return { kind: 'conflict', files, detail: gitFailure(e) };
+    catch (first) {
+        let failure = first;
+        // Chaque tour règle le commit sur lequel le rebase s'est arrêté ; un lot ne porte pas des centaines de commits, la borne évite seulement une boucle sans fin.
+        for (let turn = 0;; turn++) {
+            if (turn >= 200 || !resolveChangelog(work, start)) {
+                const files = (tryGit(work, 'diff', '--name-only', '--diff-filter=U') ?? '').split('\n').filter(Boolean);
+                tryGit(work, 'rebase', '--abort');
+                return { kind: 'conflict', files, detail: gitFailure(failure) };
+            }
+            changelog++;
+            try {
+                run(work, 'rebase', '--continue');
+                break;
+            }
+            catch (e) {
+                failure = e;
+            }
+        }
     }
-    return { kind: 'rebased', before, after: git(work, 'rev-parse', 'HEAD') };
+    return { kind: 'rebased', before, after: git(work, 'rev-parse', 'HEAD'), changelog };
 }
 /**
  * Patch-id stable (`git patch-id --stable`) du diff cumulé de `from` à `to` (R9) : le même diff reste le même quand le contexte se déplace, il change quand

package/dist/orchestrate/launch.js

@@ -5,6 +5,7 @@ import { delimiter, join, resolve } from 'node:path';
 import { parse } from 'yaml';
 import { RafError } from '../plan.js';
 import { sandboxEnv } from './sandbox.js';
+import { SlotAbandoned } from './registry.js';
 import { killMarked, SESSION_MARK_VAR, TreeTracker } from '../proc.js';
 import { isQuotaMessage, lacksStructuredOutput, parseSession, salvageUsage, sumTokens, tokensOf } from './result.js';
 /**
@@ -105,8 +106,8 @@ export function readAgents(dir) {
     }
     return out;
 }
-/** Étapes en lecture seule : seules relancées à neuf après une coupure (une étape d'écriture a pu laisser un travail à moitié fait). */
-const READ_ONLY = new Set(['review', 'review-small', 'ux', 'precheck', 'maquette', 'fiche']);
+/** Étapes relancées à neuf après une coupure : celles en lecture seule, et `ref`, qui n'écrit que sa lecture (`lectures/a.json` ou `b.json`, le troisième regard n'écrit rien), que le programme valide ensuite (une étape d'écriture ordinaire a pu laisser un travail à moitié fait). */
+const READ_ONLY = new Set(['review', 'review-small', 'ux', 'precheck', 'maquette', 'fiche', 'ref']);
 /** Session tuée par un signal (code 128 + n : 143 SIGTERM, 137 SIGKILL…) sans rien écrire : la coupure, ni un quota (un message) ni un échec (une sortie). */
 const isCut = (out) => !out.timedOut && out.code > 128 && out.stdout.trim() === '';
 /** Consigne de la relance de mise en forme : rendre le rapport déjà établi au format demandé, rien d'autre. */
@@ -149,7 +150,12 @@ export async function runSession(spec, deps) {
         const relaunched = { sessionId: spec.sessionId, cause: `code ${out.code}, sortie vide`, stderr: out.stderr };
         const fresh = randomUUID();
         deps.onRelaunch?.(fresh); // l'appelant l'enregistre AVANT le lancement : un signal pendant la relance retrouve la session neuve
-        const again = await launch(buildArgs({ ...spec, sessionId: fresh }, deps.agents));
+        // Relance qui doit attendre un créneau et voit une demande d'arrêt (L332) : la session coupée ne se perd pas avec l'abandon.
+        const again = await launch(buildArgs({ ...spec, sessionId: fresh }, deps.agents)).catch((e) => {
+            if (e instanceof SlotAbandoned)
+                e.after = { relaunched };
+            throw e;
+        });
         const next = classify(again);
         if (next.kind === 'ok')
             return { ...next, relaunched };
@@ -160,7 +166,11 @@ export async function runSession(spec, deps) {
     if (!missing)
         return first;
     const spentFirst = first.kind === 'failed' ? first.tokens : undefined;
-    const second = classify(await launch(buildRetryArgs(spec, missing.sessionId, deps.agents)));
+    const second = classify(await launch(buildRetryArgs(spec, missing.sessionId, deps.agents)).catch((e) => {
+        if (e instanceof SlotAbandoned)
+            e.after = { formatting: { stdout: out.stdout, stderr: out.stderr, ...(spentFirst ? { tokens: spentFirst } : {}), sessionId: missing.sessionId } };
+        throw e;
+    }));
     const total = (t) => (spentFirst && t ? sumTokens(spentFirst, t) : (t ?? spentFirst));
     if (second.kind === 'ok')
         return { kind: 'ok', result: { ...second.result, tokens: total(second.result.tokens), formattingRetry: true }, firstStdout: out.stdout };