@sylad/cadence 1.36.0 → 1.38.0

package/dist/orchestrate/cycle.js

@@ -10,7 +10,7 @@ import { planLoader, readDocsConfig, readPlanConfig } from '../config.js';
 import { PLAN_ACTIONS, leadAnswerMessage, planCommitMessage } from '../plan-commit.js';
 import { articleRepoDir, articlesBrief, docSyncBrief, docSyncGaps, filesOf, gapMessage } from '../docsync.js';
 import { testGateMissing } from '../testgate.js';
-import { citesPriorWork, precheckNothingToFind } from './precheck.js';
+import { citesPriorWork, keepPrecheckReading, localYesNote, precheckNothingToFind } from './precheck.js';
 import { PROBE_FAILED, PROBE_RESERVE, probeStep, probeVars, scheduleProbe } from './probe.js';
 import { changedFiles, dirtyPaths, gitCommonDir, isAncestor, readCommits, resolveCommit, restoreWorktree, tryGit } from '../git.js';
 import { blockingLots, gitCommitsIn } from './table.js';
@@ -24,7 +24,7 @@ import { TEST_WORKERS_ENV, testWorkersText } from './workers.js';
 import { baselineCandidates, gateLabel, gateReplayable, gateUnnamed, redAloneGate, redCandidates, replayGate, runGate } from './gate-parts.js';
 import { withPlace } from './gate-place.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
-import { capturesText, gateText, headline, integrationText, localReading, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, tiersText, tmpText } from './briefs.js';
+import { capturesText, EXPRESS_BRIEF, expressNewsText, gateText, headline, integrationText, localReading, precheckBrief, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, tiersText, tmpText } from './briefs.js';
 import { SlotAbandoned } from './registry.js';
 import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, trackGroup, writeMcpConfig, enabledPlugins, settingsFiles } from './launch.js';
 import { cleanPlaywrightOutput, pushed, remoteAdvances, snapshot } from './guard.js';
@@ -37,8 +37,9 @@ 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 { handBackWithoutFinding } from './no-finding.js';
 import { decisionsText, humanDecisions } from './decisions.js';
-import { LOCAL_PRECHECK_UNREADABLE, PRECHECK_UNREADABLE, lotKey, lotRepoPaths, neighbourDirs } from './state.js';
+import { LOCAL_PRECHECK_UNREADABLE, PRECHECK_UNREADABLE, expressSummary, lotKey, lotRepoPaths, neighbourDirs } from './state.js';
 import { advance, baseMoved, INTEGRATE_WAIT_MS, MAX_REPLAYS, mergeBase, patchId, rebaseOnto, repoBranch, takeRepoWrite } from './integrate.js';
 import { mutexFor } from './mutex.js';
 import { readTier, stillThird, takeTiers, tierMoved, tierRepos, wipBranch } from './tiers.js';
@@ -516,10 +517,10 @@ function briefFor(c, kind, local = false) {
     const l = c.lot;
     const lot = plan.lot(l.lot);
     const tmpDir = c.wave.store.tmpDir(l.project, l.lot);
-    const vars = { chemin: wd(c), lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', tmp: tmpText(tmpDir), workers: writesCode(kind) ? workersText(c) : '', gate: writesCode(kind) ? gateText(c.config) : '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []), integration: c.integration ? integrationText(c.integration.base) : '' };
+    const vars = { chemin: wd(c), lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', express: kind === 'implement' && l.express ? EXPRESS_BRIEF : '', tmp: tmpText(tmpDir), workers: writesCode(kind) ? workersText(c) : '', gate: writesCode(kind) ? gateText(c.config) : '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []), integration: c.integration ? integrationText(c.integration.base) : '' };
     if (l.visible) {
         const pwDir = playwrightDir(c.wave.store.lotDir(l.project, l.lot));
-        vars.news = newsText(l.lot, pwDir);
+        vars.news = l.express ? expressNewsText(pwDir) : newsText(l.lot, pwDir);
         vars.captures = capturesText(pwDir);
     }
     if (mcpServersFor(kind, l.visible, '', l.small, !!l.screen).playwright)
@@ -593,8 +594,10 @@ function briefFor(c, kind, local = false) {
                 ? `A previous session was interrupted; resume from these commits of the lot already present:\n${mine}`
                 : 'A previous session was interrupted before any commit of the lot; start again from the current state of the repository.';
         }
-        if (kind === 'implement' && l.precheck)
-            vars.commits = [vars.commits, l.precheck].filter(Boolean).join('\n');
+        // La lecture ne va qu'à la première passe implement : la session en cours (« running ») ne compte pas, toute autre passe implement déjà jouée l'exclut.
+        const firstPass = !l.steps.some((s) => s.kind === 'implement' && s.status !== 'running');
+        if (kind === 'implement')
+            vars.commits = precheckBrief(vars.commits, l.precheck, firstPass ? l.precheckLu : undefined);
         if (l.pendingAnswer)
             vars.reponse = `Answer from the human to your earlier question: ${l.pendingAnswer}`;
     }
@@ -1367,6 +1370,8 @@ async function precheck(c) {
                 localYes = true;
                 rep = null;
             }
+            else if (rep)
+                rep.lu = undefined; // « non » ou « partiel » du local, accepté sans relecture par Sonnet : sa lecture n'est pas gardée (L523)
         }
     }
     if (!rep) {
@@ -1383,11 +1388,8 @@ async function precheck(c) {
             return;
         }
     }
-    if (localYes) {
-        l.warnings.push(rep.dejaPresent === 'oui'
-            ? 'contrôle préalable : « oui » du modèle local, confirmé par Sonnet'
-            : `contrôle préalable : le modèle local a dit « oui », Sonnet dit « ${rep.dejaPresent} » — le local s'est trompé, repasser orchestrate.precheck à true`);
-    }
+    if (localYes)
+        l.warnings.push(localYesNote(rep.dejaPresent));
     const proofs = rep.preuves.length ? ` (${rep.preuves.join(' ; ')})` : '';
     // « oui » sans preuve ne se vérifie pas : il vaut « partiel », l'implémentation part avec le constat.
     const unproven = rep.dejaPresent === 'oui' && rep.preuves.length === 0;
@@ -1402,13 +1404,14 @@ async function precheck(c) {
         l.precheck = `A pre-check found part of the deliverable already in the repository (do not redo it): ${rep.resume.trim()}${proofs}`;
         l.warnings.push(`contrôle préalable : livrable en partie présent — ${rep.resume.trim()}${proofs}`);
     }
+    keepPrecheckReading(l, rep.lu);
     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))
+    if (c.lot.express || !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)
@@ -2015,6 +2018,8 @@ async function runChecks(c, red, runs, place) {
         if (!command)
             continue;
         l.gate = { label, started: new Date().toISOString() };
+        if (label === 'tests')
+            l.suiteRuns = (l.suiteRuns ?? 0) + 1;
         save(c);
         const r = await runGate(place.run, command); // porte en parties (L512) : toutes jouées, chacune dans son dossier ; le CheckRun porte le libellé « dir : run ; … »
         const run = { label, command: gateLabel(command), code: r.code, ...place.stamp() };
@@ -2246,7 +2251,7 @@ async function work(c, kind) {
     else if (made === 0)
         l.warnings.push(kind === 'fix' ? 'fix sans nouveau commit : revue lancée sur les commits du lot, avec la raison de la session (choix)' : `${kind} sans nouveau commit : revue lancée sur les commits déjà faits du lot`);
     const red = [];
-    // Tests annoncés rouges (L213) : avec orchestrate.test, le programme rejoue et compare à la ligne de base, la session n'est crue que si les tests y sont rouges autrement que par des échecs de départ ; sans, la liste des échecs de base de la session, non vérifiée.
+    // Tests annoncés rouges (L213) : avec orchestrate.test, le programme rejoue et compare à la ligne de base, la session n'est crue que si les tests y sont rouges autrement que par des échecs de départ, et jamais quand sa porte est verte (L522, quels que soient echecsDeBase et nouveauxEchecs) ; sans, la liste des échecs de base de la session, non vérifiée.
     const claimed = { source: 'tests', gravite: 'bloquant', texte: `tests annoncés rouges par la session : ${rep.tests.commande} — ${rep.tests.resultat}` };
     let deferred = false;
     const declared = (rep.echecsDeBase ?? []).map((t) => t.trim()).filter(Boolean);
@@ -2278,12 +2283,8 @@ async function work(c, kind) {
     }
     if (red.length === 0)
         await programChecks(c, red, runs);
-    // La session annonçait des tests rouges et le programme ne les voit ni déjà rouges au départ (L213) ni instables sous charge (L354, verts rejoués seuls) : l'annonce vaut.
-    // L361 : la porte du programme est verte (code 0) et la session n'annonce que des échecs de base (echecsDeBase non vide, nouveauxEchecs présent et vide) : rien de rouge pour le programme, rien de nouveau pour la session → revue, sans correction ni escalade.
-    const gateGreen = runs.some((r) => r.label === 'tests' && r.code === 0);
-    const baseOnly = declared.length > 0 && !!newFailures && !newFailures.length;
-    if (deferred && red.length === 0 && gateGreen && baseOnly)
-        l.warnings.push(`tests annoncés rouges par la session, mais la porte du programme verte (${gateLabel(c.config.test ?? '')}, code 0) et aucun nouvel échec déclaré (nouveauxEchecs vide) : les échecs sont ceux de la base qu'elle déclare (${declared.length}) ; pas de correction`);
+    if (deferred && red.length === 0 && runs.some((r) => r.label === 'tests' && r.code === 0 && !r.instables?.length))
+        l.warnings.push(`tests annoncés rouges par la session, mais la porte du programme verte (${gateLabel(c.config.test ?? '')}, code 0) : l'annonce n'est pas crue, pas de correction`);
     else if (deferred && red.length === 0 && !runs.some((r) => r.label === 'tests' && (r.dejaRouges || r.instables?.length)))
         red.push(claimed);
     if (red.length) {
@@ -2292,7 +2293,7 @@ async function work(c, kind) {
     }
     // Porte « code modifié sans test » (L287) : le diff du lot (son dépôt et ses voisins, fichiers supprimés exclus), toutes sessions comprises, touche du code sans fichier de test → correction directe, sans session de revue. Une seule fois par lot, jamais pendant la passe des mineurs, ni quand la correction prendrait la dernière passe (la revue n'en aurait plus), ni quand le budget du lot ne paie plus la correction (la revue, elle, part toujours).
     const gate = c.config.testGate;
-    if (gate && !l.testGate && !minorsPass) {
+    if (gate && !l.testGate && !minorsPass && !l.express) {
         // Le diff du lot : son dépôt et ses dépôts voisins (comme hasWork), sans les fichiers que le lot supprime (du code mort supprimé n'a pas de test à écrire).
         const touched = new Set([
             ...filesOf(wd(c), lotWork(plan, wd(c), l.lot), { withoutDeleted: true }),
@@ -2340,6 +2341,9 @@ async function toReview(c, runs, minorsPass) {
         }
     }
     l.constats = [];
+    // Voie express (L519) : pas de revue séparée, le lead lit le diff ; le lot conclut sur le HEAD que la porte du programme vient de jouer.
+    if (l.express)
+        return conclude(c, expressSummary(git(wd(c), 'rev-parse', 'HEAD')));
     l.checks = runs.length ? { head: git(wd(c), 'rev-parse', 'HEAD'), tree: git(wd(c), 'rev-parse', 'HEAD^{tree}'), runs } : undefined;
     l.next = firstReview(c);
     save(c);
@@ -2518,6 +2522,8 @@ async function reviewStep(c, kind) {
         // L'UX est la dernière étape (L221) : conforme, le lot conclut avec la revue de code ; sinon une correction (jamais une revue de code d'office), la revue de code et l'UX rejouée suivent.
         if (summary.conforme)
             return () => conclude(c, l.code, noCommitNote(l));
+        if (handBackWithoutFinding(c, l.constats, summary, stop))
+            return;
         toFix(c, l.constats, 'UX non conforme');
         return;
     }
@@ -2586,6 +2592,8 @@ async function reviewStep(c, kind) {
         return;
     }
     const constats = blockingConstats(rep, 'code');
+    if (handBackWithoutFinding(c, constats, summary, stop))
+        return;
     (l.reviewCounts ??= []).push(constats.length);
     toFix(c, constats, 'revue non conforme');
 }

package/dist/orchestrate/depot.js

@@ -3,6 +3,7 @@ import { sharedStateDir } from '../state.js';
 import { addHint } from './ajout.js';
 import { canInstallPrePush, gitProcessRunning, indexLockRefusal, snapshot } from './guard.js';
 import { activeLock, REPO_LOCK } from './lock.js';
+import { heldRefusal } from '../local-task.js';
 /** Les fichiers suivis modifiés d'un dépôt. */
 export async function trackedDirty(repo) {
     return (await snapshot(repo, { remote: false })).tracked.map((l) => l.slice(3));
@@ -28,6 +29,6 @@ export async function repoRefusals(repo, t, run, opts) {
             out.push(`${name} : ${hook}`);
     }
     if (busy && !opts.resume && !ours)
-        out.push(`${name} : une orchestration y est déjà en cours (${busy.wave}, pid ${busy.pid})${addHint(t, busy.wave, run.launch)}`);
+        out.push(`${heldRefusal(repo, busy)}${addHint(t, busy.wave, run.launch)}`);
     return out;
 }

package/dist/orchestrate/express.js

@@ -0,0 +1,10 @@
+/** Estimation, en jours, au plus de laquelle un lot est une retouche : l'étude L517 (levier 2) mesure 15,5 min et 116 k jetons pour un tel lot, dont 44 % en revue et préparation. */
+export const EXPRESS_MAX_ESTIMATE = 0.1;
+/**
+ * Voie express (L519) : une retouche (estimate ≤ 0,1 j) sans écran ni spec se joue en une seule session d'écriture, sans contrôle préalable, sans sonde
+ * ni revue séparée (le lead lit le diff), sans porte « code sans test » ni entrée Nouveautés par lot. Une estimation absente, nulle ou illisible n'en est pas une.
+ */
+export function isExpress(lot) {
+    const e = lot.estimate;
+    return typeof e === 'number' && e > 0 && e <= EXPRESS_MAX_ESTIMATE && !lot.screen && !lot.specLot;
+}

package/dist/orchestrate/gate-notes.js

@@ -3,13 +3,19 @@ import { lotKey } from './state.js';
 /** Trace des tests instables sous charge (L354) : le lot (`instables`, journal et `cadence perf`), un avertissement du lot (tableau de fin de vague) et une ligne du journal de la vague. */
 export function noteUnstable(c, tests) {
     const l = c.lot;
-    const fresh = tests.filter((t) => !(l.instables ?? []).includes(t));
+    const fresh = [...new Set(tests)].filter((t) => !(l.instables ?? []).includes(t));
     if (!fresh.length)
         return;
     l.instables = [...(l.instables ?? []), ...fresh];
     const text = `${fresh.length} test(s) instable(s) sous charge (rouge(s) dans la suite, vert(s) rejoué(s) seul(s)), pas de passe de correction : ${fresh.join(' ; ')}`;
     l.warnings.push(text);
     c.wave.log(`${lotKey(l.project, l.lot)} · ${text}`);
+    // Le rouge de charge ne coûte plus de passe, mais la dette reste au lead : un lot à stabiliser (L522).
+    for (const t of fresh) {
+        const proposal = `[instable] ${t} — rouge dans la suite, vert rejoué seul : à stabiliser`;
+        if (!l.proposals.includes(proposal))
+            l.proposals.push(proposal);
+    }
     c.wave.store.writeLot(l);
 }
 const seconds = (ms) => `${Math.round(ms / 100) / 10} s`.replace(/\.0 s$/, ' s');

package/dist/orchestrate/lock.js

@@ -16,6 +16,8 @@ export function holderAlive(pid, start) {
 }
 /** Nom du verrou d'orchestration d'un dépôt, dans l'état commun aux worktrees (celui de `deliver`). */
 export const REPO_LOCK = 'orchestrate.lock';
+/** Un champ facultatif du verrou, tel qu'écrit ; absent : absent. */
+const optional = (v) => (v === undefined ? undefined : String(v));
 function read(file) {
     let text;
     let ageMs;
@@ -28,13 +30,15 @@ function read(file) {
     }
     try {
         const raw = JSON.parse(text);
-        return { pid: Number(raw.pid), wave: String(raw.wave), started: String(raw.started), start: raw.start === undefined ? undefined : String(raw.start), ageMs };
+        return { pid: Number(raw.pid), wave: String(raw.wave), started: String(raw.started), start: optional(raw.start), until: optional(raw.until), ageMs };
     }
     catch {
         return { pid: 0, wave: '?', started: '?', unreadable: true, ageMs };
     }
 }
-const alive = (l) => (l.unreadable ? l.ageMs < 5_000 : holderAlive(l.pid, l.start));
+const alive = (l) => (l.unreadable ? l.ageMs < 5_000 : l.until !== undefined || holderAlive(l.pid, l.start));
+/** Un verrou déclaré dont l'échéance est passée à `now` ; faux pour un verrou de processus (il n'a pas d'échéance). */
+export const lockOverdue = (l, now) => l.until !== undefined && Date.parse(l.until) <= now.getTime();
 /** Le verrou s'il est tenu par un processus vivant, sinon null (absent ou périmé). */
 export function activeLock(file) {
     const l = read(file);
@@ -75,7 +79,7 @@ export function takeLock(file, given) {
         }
         const now = read(aside);
         if (now && now.pid === seen.pid && now.wave === seen.wave && now.started === seen.started && now.start === seen.start) {
-            stale = { pid: seen.pid, wave: seen.wave, started: seen.started, start: seen.start };
+            stale = { pid: seen.pid, wave: seen.wave, started: seen.started, start: seen.start, until: seen.until };
             rmSync(aside, { force: true });
         }
         else {

package/dist/orchestrate/no-finding.js

@@ -0,0 +1,19 @@
+// Une revue non conforme n'ouvre une passe de correction que si elle laisse un constat actionnable (L522).
+import { lotKey } from './state.js';
+/**
+ * Un constat est actionnable quand il est bloquant ou majeur et que son texte, rogné, n'est pas vide (`blockingConstats` ne garde déjà que les bloquants et majeurs).
+ * Les totaux annoncés peuvent être > 0 sans constat lisible (`summarize` retient le plus grand) : la session fix n'aurait rien à lire, le lot est rendu avec les totaux dans la cause.
+ * Ses constats sont vidés : une reprise (`resumedFrom && constats.length`) ne rouvre pas la passe. `stop` est celui du cycle. Vrai quand le lot est rendu.
+ */
+export function handBackWithoutFinding(c, constats, summary, stop) {
+    if (constats.some((k) => k.texte.trim()))
+        return false;
+    c.lot.constats = [];
+    const esc = c.lot.escalation;
+    if (esc && !esc.issue) { // la revue neuve de l'escalade (L337) n'a pas jugé le lot conforme : comme `toFix`, l'escalade est dite rendue et tracée
+        esc.issue = 'rendu';
+        c.wave.log(`${lotKey(c.lot.project, c.lot.lot)} · escalade ${esc.model} : lot rendu malgré l'escalade`);
+    }
+    stop(c, 'handed-back', `revue non conforme sans constat actionnable (${summary.bloquants} bloquant(s), ${summary.majeurs} majeur(s) annoncé(s), aucun constat lisible) : pas de passe de correction`);
+    return true;
+}

package/dist/orchestrate/precheck.js

@@ -77,3 +77,37 @@ export function precheckNothingToFind(plan, root, lot, repos = [], goal) {
         return null;
     }
 }
+/** Taille permise de la lecture du précheck rangée dans l'état du lot, marqueur compris (L523). */
+export const PRECHECK_LU_MAX = 4000;
+const PRECHECK_LU_CUT = '[…tronqué]';
+/** Ligne du journal quand Sonnet a relu un « oui » du modèle local (L146) : il le confirme ou le contredit. */
+export function localYesNote(verdict) {
+    return verdict === 'oui'
+        ? 'contrôle préalable : « oui » du modèle local, confirmé par Sonnet'
+        : `contrôle préalable : le modèle local a dit « oui », Sonnet dit « ${verdict} » — le local s'est trompé, repasser orchestrate.precheck à true`;
+}
+/**
+ * Range la lecture du précheck (`lu` du rapport, facultatif : `checkShape` ne le contrôle pas) dans `precheckLu` du lot : rognée de ses
+ * espaces, coupée à `PRECHECK_LU_MAX` caractères marqueur compris (au plus : un caractère hors plan de base n'est pas coupé en deux). Elle remplace toute lecture rangée plus tôt. Rien n'est rangé quand `lu` est absent, vide ou d'espaces ; un `lu`
+ * qui n'est pas une chaîne est écarté avec un avertissement.
+ */
+export function keepPrecheckReading(lot, lu) {
+    delete lot.precheckLu; // un précheck rejoué sans lecture ne laisse pas l'ancienne
+    if (lu === undefined)
+        return;
+    if (typeof lu !== 'string') {
+        lot.warnings.push('contrôle préalable : champ lu ignoré (mal typé)');
+        return;
+    }
+    const text = lu.trim();
+    if (!text)
+        return;
+    if (text.length <= PRECHECK_LU_MAX) {
+        lot.precheckLu = text;
+        return;
+    }
+    let end = PRECHECK_LU_MAX - PRECHECK_LU_CUT.length;
+    if (/[\uD800-\uDBFF]/.test(text[end - 1]))
+        end -= 1; // ne pas couper une paire de substitution en deux
+    lot.precheckLu = `${text.slice(0, end)}${PRECHECK_LU_CUT}`;
+}

package/dist/orchestrate/probe.js

@@ -15,7 +15,7 @@ const PROBE_FINDING = 'sonde de cas limites : ';
  * Sans la clé `orchestrate.probe`, rien : ni champ ni warning.
  */
 export function scheduleProbe(config, l, o) {
-    if (!config.probe || l.probe || o.skip)
+    if (!config.probe || l.probe || o.skip || l.express)
         return false;
     l.probe = true;
     if (!o.late && o.pays) {

package/dist/orchestrate/schemas.js

@@ -47,10 +47,10 @@ export const REVIEW_SCHEMA = {
     },
     required: ['bloquants', 'majeurs', 'mineurs', 'constats', 'sousTaches', 'nonVerifie', 'verdict'],
 };
-/** Sortie du contrôle préalable : `dejaPresent` vaut « oui » (rien à faire), « partiel » ou « non ». */
+/** Sortie du contrôle préalable : `dejaPresent` vaut « oui » (rien à faire), « partiel » ou « non ». `lu` (L523, facultatif) est ce que le lecteur a lu : fichiers, code voisin, tests. */
 export const PRECHECK_SCHEMA = {
     type: 'object',
-    properties: { dejaPresent: { type: 'string', enum: ['oui', 'partiel', 'non'] }, preuves: strings, resume: str },
+    properties: { dejaPresent: { type: 'string', enum: ['oui', 'partiel', 'non'] }, preuves: strings, resume: str, lu: str },
     required: ['dejaPresent', 'preuves', 'resume'],
 };
 /** Sortie de la sonde de cas limites (L497) : les tests commités, et `echecs` les tests qu'elle annonce rouges (« test — borne — attendu », un par entrée). */

package/dist/orchestrate/state.js

@@ -8,6 +8,8 @@ import { pidAlive } from '../state.js';
 /** Avertissement d'un rapport du précheck local illisible : l'étape reste `ok`, le lot se replie sur Sonnet (L322, lu par `cadence perf` pour compter l'échec du local). */
 export const LOCAL_PRECHECK_UNREADABLE = 'contrôle préalable : rapport du modèle local illisible';
 export const PRECHECK_UNREADABLE = 'contrôle préalable illisible, implémentation lancée';
+/** Ce que la voie express (L519) enregistre à la place d'une revue : conforme sans constat, la lecture du diff étant celle du lead. `head` : le HEAD que la porte du programme vient de jouer. */
+export const expressSummary = (head) => ({ conforme: true, bloquants: 0, majeurs: 0, mineurs: 0, verdict: 'conforme : voie express (retouche de 0,1 j au plus), pas de revue séparée — le lead lit le diff et regarde la capture', sousTaches: [], nonVerifie: [], head });
 export function newLot(o) {
     return { ...o, status: 'queued', pass: 0, next: null, steps: [], constats: [], verdict: null, uxVerdict: null, questions: [], choix: [], answers: [], proposals: [], warnings: [], instables: undefined, delaisJustes: undefined, outcome: null };
 }

package/dist/orchestrate/table.js

@@ -248,8 +248,8 @@ export function renderDetail(lots, sel) {
 }
 /** Le tableau de fin de vague (ou de `--status`), une ligne par lot puis le total et les questions. `compact` (L441, `--status`) : sans le détail des lots, une seule ligne renvoie à `--status --detail`. */
 export function renderTable(wave, lots, deps = {}) {
-    const rows = lots.map((l) => [`${l.project}:${l.lot}`, stateText(l, wave, deps.now ?? Date.now()), String(l.pass), review(l), ux(l), String(commits(l)), k(counted(l)), `${minutes(l)} min`]);
-    const head = ['lot', 'état', 'passes', 'revue', 'UX', 'commits', 'tokens', 'durée'];
+    const rows = lots.map((l) => [`${l.project}:${l.lot}`, stateText(l, wave, deps.now ?? Date.now()), String(l.pass), review(l), ux(l), String(commits(l)), k(counted(l)), `${minutes(l)} min`, String(l.suiteRuns ?? '—')]);
+    const head = ['lot', 'état', 'passes', 'revue', 'UX', 'commits', 'tokens', 'durée', 'suites'];
     const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
     const line = (r) => r.map((c, i) => c.padEnd(widths[i])).join('  ').trimEnd();
     const out = [line(head), ...rows.map(line)];

package/dist/plan.js

@@ -38,6 +38,7 @@ function cleanUses(names) {
             throw new RafError(invalidResource(n));
     return [...new Set(names)];
 }
+const trueFlags = (flags) => Object.fromEntries(Object.entries(flags).filter(([, on]) => on).map(([k]) => [k, true])); // les drapeaux vrais, chacun à `true` : les absents et les faux ne s'écrivent pas
 export const FIELDS = ['id', 'title', 'status', 'estimate', 'quickwin', 'visible', 'screen', 'spec', 'public', 'every', 'last', 'after', 'created', 'started', 'finished', 'notes', 'repos', 'parent', 'gate', 'goal'];
 /** Nature de l'écran d'un lot visible : nouvelle page, nouveau composant, parcours modifié. */
 export const SCREENS = ['page', 'component', 'journey'];
@@ -562,15 +563,10 @@ export class Plan {
         const entry = { id, title };
         if (pub !== undefined)
             entry.public = pub;
-        Object.assign(entry, { status: 'todo', estimate: opts.estimate ?? 1 });
-        if (opts.quickwin)
-            entry.quickwin = true;
-        if (opts.visible)
-            entry.visible = true;
+        Object.assign(entry, { status: 'todo', estimate: opts.estimate ?? 1 }, trueFlags({ quickwin: opts.quickwin, visible: opts.visible }));
         if (opts.screen)
             entry.screen = opts.screen;
-        if (opts.spec)
-            entry.spec = true;
+        Object.assign(entry, trueFlags({ spec: opts.spec, local: opts.local }));
         if (opts.every !== undefined)
             entry.every = opts.every;
         if (opts.after?.length)
@@ -1070,7 +1066,7 @@ function normalizeLot(raw, problems = []) {
         quickwin: raw.quickwin === true,
         visible: raw.visible === true,
         ...(screen ? { screen } : {}),
-        ...(spec ? { spec } : {}),
+        ...(spec ? { spec } : {}), ...(raw.local === true ? { local: true } : {}),
         ...(gate ? { gate } : {}),
         ...(typeof raw.public === 'string' && raw.public.trim() !== '' ? { public: raw.public.trim() } : {}),
         ...(typeof raw.goal === 'string' && raw.goal.trim() !== '' ? { goal: raw.goal.trim() } : {}),

package/dist/repo-busy.js

@@ -0,0 +1,47 @@
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+import { gitRoot } from './git.js';
+import { activeLock, REPO_LOCK } from './orchestrate/lock.js';
+import { INTEGRATION_LOCK } from './orchestrate/integrate.js';
+import { mainTreeWorkers } from './orchestrate/main-tree.js';
+import { cadenceHome, openLotsIn } from './orchestrate/registry.js';
+import { sharedStateDir } from './state.js';
+// Ce que `raf`, `deliver` et `spec` lisent du verrou du dépôt : une orchestration (ou une tâche locale du lead, L519) qui le tient, ou une intégration en cours.
+/**
+ * Avertit (stderr, sans refuser) quand une intégration du dépôt est en cours (L425) : le plan écrit dans l'arbre principal est un fichier suivi modifié, et
+ * l'intégration en cours le voit et refuse son lot (« arbre du dépôt modifié »). Seul l'arbre principal est concerné : dans le worktree d'un lot, l'écriture
+ * ne change pas l'arbre que l'intégration contrôle.
+ */
+export function warnIntegrating(root, err) {
+    const top = gitRoot(root);
+    if (!top || !statSync(join(top, '.git')).isDirectory())
+        return;
+    const holder = activeLock(join(sharedStateDir(root), INTEGRATION_LOCK));
+    if (holder)
+        err(`avertissement : intégration en cours (vague ${holder.wave}, pid ${holder.pid}) — ce plan est un fichier suivi modifié de l'arbre principal, l'intégration en cours peut refuser son lot (arbre du dépôt modifié) : committer le plan sans attendre`);
+}
+/**
+ * Avertit (stderr, sans refuser) quand une session de vague écrit dans l'arbre principal du dépôt (L475) : un lot en implémentation, revue ou correction sans worktree.
+ * Un commit de plan du lead à ce moment-là rend le lot (cas du 30-10 : cadence L458 rendu par le commit du plan). Sans effet dans le worktree d'un lot, ou depuis une session de la vague (c'est elle qui tient l'arbre).
+ */
+export function warnWaveWorking(root, env, err) {
+    if (env.CADENCE_ORCHESTRATED)
+        return;
+    const top = gitRoot(root);
+    if (!top || !statSync(join(top, '.git')).isDirectory())
+        return;
+    const holder = activeLock(join(sharedStateDir(root), REPO_LOCK));
+    if (!holder)
+        return;
+    const working = mainTreeWorkers(cadenceHome(), holder.pid, top);
+    if (working?.length)
+        err(`avertissement : la vague ${holder.wave} (pid ${holder.pid}) travaille dans l'arbre principal de ce dépôt (${working.join(', ')}) — un commit de plan maintenant rendrait ces lots à la revue ; attendre la fin de leur étape, ou écrire le plan sans le committer`);
+}
+/** La vague qui tient le verrou du dépôt tant qu'un de ses lots y travaille encore (état illisible : on la tient pour active) ; null si le dépôt est libre. Partagé par `deliver` et `spec reseal`. */
+export function waveHolding(root) {
+    const orchestrating = activeLock(join(sharedStateDir(root), REPO_LOCK));
+    if (!orchestrating)
+        return null;
+    const stillOpen = openLotsIn(cadenceHome(), orchestrating.pid, root);
+    return stillOpen === null || stillOpen.length > 0 ? orchestrating : null;
+}

package/docs/corrections.md

@@ -37,3 +37,5 @@ The cause `bug-code` alone is 69 % of the classified passes (74 of 107, 24→30-
 ## Passes launched on tests that ended without a code change (L510)
 
 A pass with no review finding to read is a pass the gate launched on **red tests** right after a write session (`sans revue (tests rouges)` above). When such a pass ends with **no commit**, the session found nothing to change: the red was a false red (a timeout under load, a test that was already red) or the test needed no fix. `cadence corrections` prints, after the report, `N passes lancées sur des tests, M terminées sans changement de code (P %)` (nothing when there is no pass on tests) and adds `testsSansCode: { passes, sansCode }` to `--json`. The line is outside the report of the 10-10 baseline, which `test/corrections-mesure.test.ts` replays word for word. Two windows are measured with `--since` and `--until` (a window of creation dates of the waves, see above): the figures of the last two 7-day windows are in [mesures/tests-sans-code-2026-11-01.md](mesures/tests-sans-code-2026-11-01.md).
+
+Where the wall time and the tokens of a lot go — tests, reads, news, captures, reviews, correction passes with their cause and cost (11.9 min and 126 k tokens a pass), gate, integration — is measured over the 15 days of 17-10 → 01-11 by `node scripts/temps-d-un-lot.mjs` (L517): [mesures/temps-d-un-lot.md](mesures/temps-d-un-lot.md), with the command to replay it and the three levers it sizes (L518, L519, L447).

package/docs/mesures/brief-implementation-enrichi-avant-apres.md

@@ -0,0 +1,36 @@
+# Mesure avant/après du brief d'implémentation enrichi (L523)
+
+Le brief `implement` porte désormais la grille du code-reviewer, l'ordre « tests des cas limites d'abord, relecture contre la grille avant le dernier commit », et, après un précheck, la lecture qu'il a faite (fichiers concernés, code voisin à imiter, tests existants). Ce document est le protocole qui mesure l'effet, et la ligne « avant » relevée par l'étude L517 (`docs/mesures/temps-d-un-lot.md`). Au moment de l'implémentation de L523 la copie en service de l'outil ne contient pas encore le brief enrichi (le lead ne la met à jour qu'après la revue, `npm run service -- <sha>`) : il n'existe donc aucune vague créée avec lui, et la ligne « après » est un emplacement à renseigner. Aucun chiffre « après » n'est écrit ici.
+
+## Les trois mesures
+
+Elles se relèvent avec `scripts/temps-d-un-lot.mjs` (livré par L517 ; il peut manquer d'une branche qui n'a pas encore reçu L517, ce document ne fait que le nommer) :
+
+- les **passes par lot** : passes de correction divisées par les lots de la fenêtre ;
+- la **cause des passes** : la part de `bug-code` (dont les cas limites) et de `derive-architecture` parmi les passes classées ;
+- les **allers-retours de lecture** par lot : appels de lecture (Read, Grep, Glob, `grep`, `cat`, `git show`…) des sessions du lot.
+
+## Borne
+
+La borne est `<borne>` à relever : l'heure de la mise en service du brief enrichi, relevée par le lead hors vague, entre deux sessions (`date -u -d "$(stat -c %y ~/.local/share/cadence/service)" +%FT%TZ`, en UTC, après le `npm run service` du sha qui porte L523). Même règle que L222 ([autocontrole-avant-revue-2026-10-15.md](autocontrole-avant-revue-2026-10-15.md)) : c'est la date de création de la vague, `created` de son `wave.json`, qui dit si un lot a reçu le brief, non le début de l'`implement` : une vague rend tous ses briefs depuis la copie de l'outil figée à sa création.
+
+- l'**avant** rejoue le script sur les lots des vagues créées jusqu'à la borne (`--until <borne>`) ;
+- l'**après** le rejoue sur les lots des vagues créées après elle (`--since <borne>`).
+
+```
+node scripts/temps-d-un-lot.mjs --runs <dossier-des-projets>/.cadence/runs --until <borne> --corrections corrections.json
+node scripts/temps-d-un-lot.mjs --runs <dossier-des-projets>/.cadence/runs --since <borne> --corrections corrections.json
+```
+
+où `corrections.json` est la sortie de `cadence corrections <dossier-des-projets> --classify --cache docs/mesures/corrections-classement.json --json` (même fenêtre).
+
+La borne est **invalide quand une vague à cheval est encore reprenable** : une vague créée avant la borne, interrompue ou suspendue, qui serait reprise (`--resume`) après elle voit des passes se terminer après la borne, que ni `--until` ni `--since` ne lisent. Avant de relever la borne, terminer ces vagues ou ne plus les reprendre (liste : `jq -r 'select(.status != "done") | "\(.id) \(.status) \(.created)"' <dossier-des-projets>/.cadence/runs/*/wave.json`) ; sinon la reposer hors vague et rejouer les deux commandes.
+
+## Résultats
+
+| | Passes par lot | Part de bug-code (dont cas limites) | Part de dérive d'architecture | Allers-retours de lecture par lot |
+|---|---|---|---|---|
+| Avant (étude L517, 17-10 → 01-11) | 0,85 (620 passes, 730 lots) | 52 % (301 passes, dont 223 cas limites) | 10 % (58 passes) | 13,4 |
+| Après (`--since <borne>`) | à renseigner | à renseigner | à renseigner | à renseigner |
+
+Limite : tant qu'aucune vague n'a tourné avec le brief enrichi, la ligne « après » reste à renseigner par le lead ; ce document n'affirme aucun gain. Le sens attendu : moins de passes par lot, une part de `bug-code` et de dérive d'architecture en baisse, moins d'allers-retours de lecture quand le précheck a rendu sa lecture. Les lots sans précheck ne reçoivent pas la lecture : seule la grille et l'ordre « cas limites d'abord » les concernent.