@sylad/cadence 1.17.1 → 1.19.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.17.1",
+      "version": "1.19.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.17.1",
+  "version": "1.19.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/agents/code-reviewer.md

@@ -22,7 +22,7 @@ fact. If the path or the id is missing, or the lot has no commit to review, say
    test, type-check, lint and build: in the README, then in the manifest (`package.json` scripts,
    Makefile, `pyproject.toml`…).
 2. **Read the lot**: its title, notes and sub-tasks in the plan (`.cadence/raf.yaml`, the legacy `docs/plan/raf.yaml`, or the file
-   named by `plan:` in `cadence.yaml`). That is the goal the commits are measured against. When the brief gives a "Goal of the lot", that goal of the lot given in the brief takes precedence over the title in the plan (a title can be stale; the goal was given on purpose): measure the commits against it, not against the title. When the
+   named by `plan:` in `cadence.yaml`; never read `.cadence/archive/`, the closed lots moved out of the plan: `raf show <id>` finds an archived lot). That is the goal the commits are measured against. When the brief gives a "Goal of the lot", that goal of the lot given in the brief takes precedence over the title in the plan (a title can be stale; the goal was given on purpose): measure the commits against it, not against the title. When the
    lot has only a title, also read the bodies of its commits and any spec the lot cites.
 3. **Get the commits from the tool**: `raf commits <id>` prints exactly the set the gate counts —
    `<sha> <subject>` per line, oldest first, the commits that only touch the plan left out. Only

package/dist/archive.js

@@ -0,0 +1,79 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Document, isMap, isSeq, parseDocument } from 'yaml';
+/**
+ * Archive du plan (L396) : un détail de STOCKAGE. Les lots done et dropped quittent le fichier `.cadence/raf.yaml` pour
+ * `.cadence/archive/<année>.yaml` (l'année de leur fin), mais le plan chargé (`Plan.load`) les présente tous : `plan.lots()`
+ * rend la même chose avant et après `raf archive`, et aucun lecteur n'a à connaître l'archive. Seul le fichier du plan
+ * actif devient petit, et les briefs disent aux sessions de ne jamais ouvrir `.cadence/archive/`.
+ */
+export const ARCHIVE_DIR = 'archive';
+/**
+ * Les lots à déplacer et ceux qui restent, parmi `lots` (ceux du fichier actif). Un lot reste seulement quand `blocked` le dit (un
+ * écart que `raf check` signale encore) : les lecteurs voyant l'archive, un lot cité par `after` ou compté par un `gate` s'archive
+ * comme les autres sans rien changer à ce qu'ils lisent. `before` : seuls les lots terminés strictement avant ce jour (un lot sans
+ * date de fin reste).
+ */
+export function selectArchivable(lots, before, blocked = () => null) {
+    const closed = (l) => (l.status === 'done' || l.status === 'dropped') && (before === undefined || (!!l.finished && l.finished < before));
+    const move = [];
+    const kept = [];
+    for (const l of lots.filter(closed)) {
+        const why = blocked(l);
+        if (why)
+            kept.push({ id: l.id, why });
+        else
+            move.push(l);
+    }
+    return { move, kept };
+}
+/** Le numéro d'un identifiant (`L12` → 12) ; NaN pour un identifiant sans numéro. */
+const num = (id) => Number(/\d+$/.exec(id)?.[0] ?? NaN);
+/**
+ * Les lots archivés remis à leur place parmi ceux du fichier actif : chacun juste avant le premier lot actif de numéro plus grand, à la fin
+ * sinon, les archivés entre eux par numéro. L'ordre du fichier actif ne bouge jamais ; un plan que `raf add` tient dans l'ordre des numéros
+ * (le cas ordinaire) se lit exactement comme avant l'archivage (L396).
+ */
+export function mergeArchived(archived, active) {
+    const queue = [...archived].sort((a, b) => num(a.id) - num(b.id) || 0);
+    const out = [];
+    for (const lot of active) {
+        const n = num(lot.id);
+        while (queue.length > 0 && !(num(queue[0].id) >= n))
+            out.push(queue.shift());
+        out.push(lot);
+    }
+    return [...out, ...queue];
+}
+/** Année de rangement d'un lot : celle de sa fin, à défaut de sa création, à défaut d'aujourd'hui. */
+export function archiveYear(lot, today) {
+    return (lot.finished ?? lot.created ?? today).slice(0, 4);
+}
+/** Fichiers `<année>.yaml` du dossier d'archive, du plus ancien au plus récent ; vide sans dossier. */
+export function archiveFiles(dir) {
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir).filter((f) => /^\d{4}\.yaml$/.test(f)).sort().map((f) => join(dir, f));
+}
+/** La liste des lots d'un document d'archive (toujours présente : `readArchiveDoc` et `newArchiveDoc` la garantissent). */
+export function archiveLots(doc) {
+    return doc.get('lots');
+}
+/** Un fichier d'archive lu tel quel ; une archive illisible est une erreur nommée, pas un lot de moins. */
+export function readArchiveDoc(file) {
+    const doc = parseDocument(readFileSync(file, 'utf8'));
+    if (doc.errors.length > 0)
+        throw new Error(`${file} : ${doc.errors[0].message}`);
+    const lots = isMap(doc.contents) ? doc.get('lots') : undefined;
+    if (!isSeq(lots))
+        throw new Error(`${file} : la clé « lots » doit porter la liste des lots archivés`);
+    lots.flow = false;
+    return doc;
+}
+/** Le document d'un fichier d'année qui n'existe pas encore. */
+export function newArchiveDoc(year) {
+    const doc = new Document({ version: 1, lots: [] });
+    doc.commentBefore = ` Lots terminés ou abandonnés de ${year}, déplacés du fichier du plan par « raf archive ». Lecture seule pour les sessions : ne pas l'ouvrir, « raf show <id> » lit un lot archivé.`;
+    archiveLots(doc).flow = false;
+    return doc;
+}

package/dist/audit.js

@@ -151,7 +151,10 @@ export function isAcknowledged(plan, c) {
 export function exemptPlanOnly(linked, plan, root) {
     const { patterns } = plan.ignore;
     const acked = (c) => isAcknowledged(plan, c);
-    const orphans = linked.orphans.filter((c) => !patterns.some((re) => re.test(c.subject)) && !acked(c) && !isPlanOnly(c.sha, plan, root) && !isReleaseOnly(c.sha, root));
+    const candidates = linked.orphans.filter((c) => !patterns.some((re) => re.test(c.subject)) && !acked(c));
+    // Les fichiers des orphelins restants se lisent d'un seul git log, pas d'un diff-tree par commit (L394).
+    preloadChangedFiles(root, candidates.map((c) => c.sha));
+    const orphans = candidates.filter((c) => !isPlanOnly(c.sha, plan, root) && !isReleaseOnly(c.sha, root));
     return { ...linked, orphans, unknown: linked.unknown.filter((u) => !acked(u.commit)) };
 }
 /** Fenêtre de l'audit : --since, sinon la date d'adoption du plan, sinon 30 jours. */
@@ -176,6 +179,7 @@ export function audit(plan, root, newsDir, today, opts = {}) {
     const linked = exemptPlanOnly(linkCommits(lots, planCommits(plan, root, { since: auditSince(plan, opts.since) }), plan.refs), plan, root);
     // L'inactivité se mesure sur tout l'historique, pas seulement la fenêtre --since.
     const all = linkCommits(lots, planCommits(plan, root), plan.refs);
+    preloadChangedFiles(root, [...all.byLot.values()].flatMap((cs) => cs.map((c) => c.sha)));
     // Un commit acquitté (`raf ignore`) qui cite des lots connus ne compte pour aucun : ni commencé, ni actif, ni à relire.
     for (const [id, cs] of all.byLot)
         all.byLot.set(id, cs.filter((c) => !isAcknowledged(plan, c)));
@@ -234,6 +238,8 @@ export function docSyncIssues(plan, root, byLot) {
 /** Commits qui portent du travail sur un lot : ni antérieurs à l'adoption du plan, ni acquittés (`raf ignore`), ni réduits au plan, ni une simple version. */
 function workCommits(plan, root, commits) {
     const adopted = plan.since;
+    // Les fichiers de tous ces commits d'un seul `git log` : le filtre ci-dessous les lit un à un (L394, un `git diff-tree` par commit coûtait 89 % de `raf check`).
+    preloadChangedFiles(root, commits.map((c) => c.sha));
     return commits.filter((c) => (!adopted || c.day >= adopted) && !isAcknowledged(plan, c) && !isPlanOnly(c.sha, plan, root) && !isReleaseOnly(c.sha, root));
 }
 /** Commits liés à un lot, du plus récent au plus ancien, avant tout tri : commits de plan et d'avant l'adoption compris. */

package/dist/cli.js

@@ -48,7 +48,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf spec <id> on|off   pose ou retire spec: d'un lot existant (le lot change un comportement : étape spec back d'orchestrate)
   raf uses <lot> [<ressource>…]   remplace les ressources partagées du lot (uses:, déclarées par resources: dans le cadence.yaml du dossier parent ; raf check refuse un nom non déclaré) ; sans nom, retire la clé
   raf start <id>        raf done <id> [--force]        raf drop <id> [--reason texte]
-  raf todo <id> [--reason texte]   remet en attente un lot démarré sans commit de travail (doing → todo, started retiré, note datée) ; refusé s'il a des commits
+  raf todo <id> [--reason texte]   remet en attente un lot démarré sans commit de travail (doing → todo, started retiré, note datée) ; refusé s'il a des commits ; rouvre un lot done ou dropped (→ todo, finished retiré, note « rouvert ») — la seule façon de rouvrir, archivé compris (il revient dans le fichier du plan)
   raf note <id> "texte"
   raf title <id> "nouveau titre"   remplace le titre d'un lot, de tout statut (done compris), et note l'ancien dans une note datée
   raf did <id> ["texte"]   un lot récurrent (--every) a été refait : le « dû depuis N j » repart de aujourd'hui
@@ -63,6 +63,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf check [--since date] [--idle 7]   (défaut : date « since » du plan) code 1 s'il y a des écarts
   raf ignore <sha> | "<sujet exact>" [--reason texte]   acquitte un commit sans lot, citant un id inconnu ou des lots sans y travailler, sans réécrire l'historique ; raf check --ignored les liste
   raf docs-ok <lot> --reason texte   acquitte l'écart docs.sync d'un lot (documentation en retard) avec la raison pour laquelle la documentation reste telle quelle (plan en lecture seule : .cadence/docs-ok.yaml, le plan n'est pas touché) ; lu par raf check et par orchestrate, qui ne rend jamais prêt un lot avec un écart ouvert
+  raf archive [--before date] [--dry-run]   déplace les lots done et dropped (terminés avant la date, s'il y en a une) du fichier du plan vers .cadence/archive/<année>.yaml ; le plan chargé présente toujours tous les lots (show, list, check, now, news, perf… inchangés), seules les sessions ne lisent jamais l'archive ; reste dans le plan un lot qui a un écart ouvert (raf check) ; un id présent dans deux fichiers est une erreur nommée ; refusé tant que le plan est à docs/plan/raf.yaml (raf migrate d'abord) ; rejouable
   raf gantt [-o .cadence/gantt.html]
   cadence config set <clé> <valeur> --all [--dry-run] [--depth n]   pose la même clé dans le cadence.yaml de chaque projet du dossier (ceux de lead tour), commentaires et ordre gardés, un lot de config qui la cite (raf add + start) et un commit à chemin explicite par projet ; ne pousse pas ; liste ce qui est fait et sauté (dépôt sale, déjà posée, plan en lecture seule) ; s'arrête sur une config qui ne se relit pas
   raf migrate [--dry-run]   déplace docs/plan/raf.yaml vers .cadence/raf.yaml (git mv) et réécrit les lecteurs du chemin dans le dépôt ; --dry-run les liste sans rien toucher ; refus tant qu'un lecteur n'est pas traité (migrate.keep de cadence.yaml pour ceux qui ne lisent pas le plan) ; rejouable
@@ -83,7 +84,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   cadence ref corpus <dossier> [--sans-rendu]   écrit le corpus synthétique à vérité connue (7 pièges : texte ambigu levé par une figure, figure qui contredit, table en image, gabarit BUFR, contrôle translucide, page Proposal, scan bruité) : par cas document.html et attendu.json, puis document.pdf et page-<n>.png (1700×2200) rendus par Playwright (CADENCE_PLAYWRIGHT = dossier du paquet) ; dossier existant ou Playwright introuvable : code 2
   cadence release patch|minor|major [--dry-run]   prépare le commit de version (package.json, package-lock.json, plugin.json, marketplace.json, CHANGELOG.md) sans commiter ni publier ; imprime les étapes du lead et vérifie docs/whats-new.md : refus sur un arbre sale, un [Unreleased] vide ou une version déjà taguée
   cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
-  cadence verify --gate --sha rév [--project dossier]   rejoue la porte du projet (orchestrate.build puis orchestrate.test) au sha dans un worktree jetable aux dépendances reliées (orchestrate.worktreeDeps), puis le retire : 0 vert, 1 rouge avec les tests en échec, 2 rien à rejouer
+  cadence verify --gate --sha rév [--project dossier]   porte du projet (orchestrate.build puis orchestrate.test) : reprend le verdict enregistré par la vague quand son sha est le même et son arbre identique, sans rien rejouer (la sortie dit « verdict repris de la porte de la vague ») ; sinon la rejoue (« verdict rejoué : raison ») au sha dans l'arbre principal s'il est propre au sha, sinon dans un worktree jetable aux dépendances copiées (orchestrate.worktreeDeps), puis le retire : 0 vert, 1 rouge avec les tests en échec, 2 rien à rejouer
   raf news new <lot…> [--title t] | list | check | stamp | build [-o dossier]   (aussi « cadence news … »)
 
 Un commit appartient à un lot quand son message cite l'identifiant : « feat(L3): … », « L3/t1 ».
@@ -177,6 +178,7 @@ function dispatch(argv, io) {
             porteur: { type: 'string' },
             status: { type: 'string' },
             since: { type: 'string' },
+            before: { type: 'string' },
             idle: { type: 'string' },
             ttl: { type: 'string' },
             session: { type: 'string' },
@@ -463,6 +465,36 @@ function dispatch(argv, io) {
             }
             return 0;
         }
+        case 'archive': {
+            if (values.before !== undefined && !isDay(values.before))
+                throw new RafError(`--before invalide : ${values.before} (attendu AAAA-MM-JJ)`);
+            // L'archive vit à côté du plan : à l'ancien emplacement, elle irait sous docs/ (publié) et raf migrate ne la déplacerait pas — migrer d'abord.
+            if (planPath === resolve(root, PLAN_LEGACY))
+                throw new RafError(`raf archive refusé : le plan est à l'ancien emplacement ${PLAN_LEGACY}, l'archive irait sous docs/ — le déplacer d'abord : raf migrate`);
+            const dry = !!values['dry-run'];
+            const plan = loadPlan();
+            // Un lot clos qui a encore un écart (revue, UX, docs.sync, Nouveauté… ce que `raf check` signale) reste dans le plan, avec l'écart pour raison.
+            const issues = audit(plan, root, newsDir, today);
+            const blocked = (lot) => issues.find((i) => plan.refs(i.message).some((r) => r.lot === lot.id))?.message ?? null;
+            const { moved, kept } = plan.archive(today, { before: values.before, dryRun: dry, blocked: (lot) => (blocked(lot) ? `écart ouvert — ${blocked(lot)}` : null) });
+            const files = [...new Set(moved.map((m) => m.file))];
+            for (const f of files) {
+                const ids = moved.filter((m) => m.file === f).map((m) => m.lot.id);
+                io.out(`${dry ? 'à archiver' : 'archivé'} dans ${relative(io.cwd, f)} : ${ids.join(', ')}`);
+            }
+            for (const k of kept)
+                io.out(`${k.id} reste dans le plan : ${k.why}`);
+            if (moved.length === 0)
+                io.out('rien à archiver');
+            else if (!dry) {
+                if (plan.republishes)
+                    io.err('raf: plan.onWrite republie le fichier du plan sans les lots archivés : le générateur de la copie publiée doit aussi lire .cadence/archive/*.yaml (clé `lots`), sinon l\'historique livré disparaît de la feuille de route publique');
+                const uncommitted = uncommittedPlanCommand(plan, root, moved[0].lot.id, planConfig?.commit, PLAN_ACTIONS.archived(moved.length));
+                if (uncommitted)
+                    io.out(uncommitted);
+            }
+            return 0;
+        }
         case 'todo': {
             need(1, 'todo <id> [--reason texte]');
             const plan = loadPlan();
@@ -831,16 +863,16 @@ function knownLot(plan, id, subtask) {
  * `raf done` écrit le plan et ne le commite jamais (voulu : raf n'a pas de réglage qui commite, docs/raf.md) : la commande de commit du plan et des fichiers
  * que `plan.onWrite` produit, au gabarit `plan.commit` du projet (L371). Null hors d'un dépôt git ou quand rien n'est à commiter.
  */
-function uncommittedPlanCommand(plan, root, lot, template) {
+function uncommittedPlanCommand(plan, root, lot, template, action = PLAN_ACTIONS.done) {
     const repo = gitRoot(root);
     if (!repo)
         return null;
     // Seuls les chemins que git voit modifiés : `git add` d'un chemin absent ou ignoré est fatal.
-    const paths = dirtyPaths(repo, [relative(repo, plan.path), ...plan.files, ...plan.produced]);
+    const paths = dirtyPaths(repo, [relative(repo, plan.path), ...plan.files, ...plan.produced, ...plan.archiveFiles().map((f) => relative(repo, f))]);
     if (paths.length === 0)
         return null;
     const quote = (t) => (/^[\w./-]+$/.test(t) ? t : `'${t.replaceAll("'", "'\\''")}'`);
-    const message = planCommitMessage(template, { lot, action: PLAN_ACTIONS.done });
+    const message = planCommitMessage(template, { lot, action });
     const list = paths.map(quote).join(' ');
     return `plan non commité : raf ne commite jamais (voulu, ce n'est pas un réglage), à commiter :\n  git add -- ${list} && git commit -m ${quote(message)} -- ${list}`;
 }
@@ -1481,7 +1513,7 @@ async function verifyGateCommand(values, io) {
     const sha = resolveCommit(top, values.sha);
     if (!sha)
         throw new RafError(`verify --gate : --sha ${values.sha} : commit introuvable dans ${top}`);
-    return verifyGate({ repo: top, sha, config: readOrchestrateConfig(configPath), verify: readVerifyConfig(configPath), out: io.out });
+    return verifyGate({ repo: top, sha, config: readOrchestrateConfig(configPath), verify: readVerifyConfig(configPath), launchDirs: [io.cwd, top, dirname(top)], out: io.out });
 }
 /** `session start|close --all [--depth n]` : la commande jouée dans chaque projet sous le dossier courant, une section par projet. */
 async function sessionAll(rest, values, io) {

package/dist/config.js

@@ -338,7 +338,7 @@ export function readVerifyConfig(file) {
     return { inPlace: v.inPlace };
 }
 const REVIEW_KEYS = ['threshold', 'light', 'full'];
-const ORCH_KEYS = ['start', 'verdict', 'test', 'testReplay', 'build', 'worktreeDeps', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'prodAccess', 'worktrees', 'testGate', 'spec', 'review', 'escalation', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'testReplay', 'build', 'worktreeDeps', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'prodAccess', 'worktrees', 'testGate', 'spec', 'review', 'escalation', 'continue', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
 /** Clé `orchestrate:` de cadence.yaml. Absente : les défauts (auto, 45 min d'implémentation, 25 min de revue). */
 export function readOrchestrateConfig(file) {
     const config = { precheck: true, maquette: true, maquetteReviews: 3, fiche: true, precheckLocal: false, prodAccess: false, worktrees: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', fiche: 'medium', accept: 'medium', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
@@ -497,6 +497,26 @@ export function readOrchestrateConfig(file) {
             throw bad('escalation.model : nom de modèle non vide attendu (passé tel quel à claude --model)');
         config.escalation = { model: m.trim() };
     }
+    if (o.continue != null) {
+        if (!isObject(o.continue))
+            throw bad('continue doit être un objet { maxEstimate, exclude }');
+        for (const k of Object.keys(o.continue))
+            if (!['maxEstimate', 'exclude'].includes(k))
+                throw bad(`continue.${k} inconnu (attendu : maxEstimate, exclude)`);
+        const { maxEstimate, exclude } = o.continue;
+        const setting = {};
+        if (maxEstimate != null) {
+            if (typeof maxEstimate !== 'number' || !(maxEstimate > 0))
+                throw bad('continue.maxEstimate : nombre de jours strictement positif attendu');
+            setting.maxEstimate = maxEstimate;
+        }
+        if (exclude != null) {
+            if (!Array.isArray(exclude) || exclude.some((x) => typeof x !== 'string' || !x.trim()))
+                throw bad('continue.exclude : liste de numéros de lots non vides attendue (ex. [L12, L40])');
+            setting.exclude = exclude.map((x) => x.trim());
+        }
+        config.continue = setting;
+    }
     if (o.effort != null) {
         if (!isObject(o.effort))
             throw bad('effort doit être un objet { precheck, spec, maquette, fiche, accept, implement, fix, review, ux }');

package/dist/gate-record.js

@@ -0,0 +1,71 @@
+import { existsSync, readdirSync, realpathSync } from 'node:fs';
+import { git } from './orchestrate/worktree.js';
+import { RunStore } from './orchestrate/state.js';
+const realOrSelf = (p) => {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+};
+/**
+ * La porte que le programme a déjà jouée pour `sha` (L397), pour que `verify --gate` la lise au lieu de la rejouer (≈ 5 min par lot prêt).
+ * Une vague range l'état de ses lots sous `<dossier de lancement>/.cadence/runs/<vague>` : `launchDirs` sont ceux à regarder (dossier courant, racine du dépôt, son parent), les vagues les plus récentes d'abord.
+ * Un enregistrement est repris quand ses contrôles ont tourné AU sha (même commit), que l'arbre de ce commit est celui enregistré, et qu'il couvre chaque étape de `steps`
+ * (même étiquette, même commande, code 0 : une étape rouge, absente ou rejouée avec une autre commande ne prouve rien). Sinon `reason` dit pourquoi la porte est rejouée.
+ */
+export function recordedGate(launchDirs, repo, sha, steps) {
+    const tree = git(repo, 'rev-parse', `${sha}^{tree}`);
+    const repoReal = realOrSelf(repo);
+    let reason = 'aucune porte de vague enregistrée pour ce sha';
+    const seen = new Set();
+    for (const dir of launchDirs) {
+        const base = RunStore.runsDir(dir);
+        if (seen.has(realOrSelf(base)) || !existsSync(base))
+            continue;
+        seen.add(realOrSelf(base));
+        const stores = readdirSync(base)
+            .map((id) => RunStore.find(dir, id))
+            .filter((s) => s !== null)
+            .map((store) => {
+            try {
+                return { store, created: store.readWave()?.created ?? '' };
+            }
+            catch {
+                return { store, created: '' };
+            }
+        })
+            .sort((a, b) => b.created.localeCompare(a.created) || b.store.id.localeCompare(a.store.id));
+        for (const { store } of stores) {
+            let lots;
+            try {
+                lots = store.lots();
+            }
+            catch {
+                continue; // état illisible (écriture en cours) : cette vague ne fournit rien
+            }
+            for (const l of lots) {
+                if (l.checks?.head !== sha || realOrSelf(l.repo) !== repoReal)
+                    continue;
+                const where = `vague ${store.id}, lot ${l.lot}`;
+                if (l.checks.tree === undefined) {
+                    reason = `arbre non enregistré (${where}, enregistrement antérieur à L397)`;
+                    continue;
+                }
+                if (l.checks.tree !== tree) {
+                    reason = `arbre différent de celui contrôlé (${where})`;
+                    continue;
+                }
+                const label = (name) => (name === 'build' ? 'build' : 'tests');
+                const missing = steps.filter((s) => !l.checks.runs.some((r) => r.label === label(s.name) && r.command === s.cmd && r.code === 0));
+                if (missing.length) {
+                    reason = `l'enregistrement (${where}) ne couvre pas en vert ${missing.map((s) => `${s.name} (${s.cmd})`).join(', ')}`;
+                    continue;
+                }
+                return { found: { wave: store.id, lot: l.lot, tree, runs: l.checks.runs } };
+            }
+        }
+    }
+    return { reason };
+}

package/dist/orchestrate/briefs.js

@@ -55,7 +55,7 @@ export function shotsText(captureDir) {
     return `The Playwright server resolves a file name you give it against the repository, not against its output directory: a bare name such as page-home.png lands at the repository root. Give every screenshot, snapshot and trace the absolute path of the wave's capture directory, \`${captureDir}/\`, followed by the name (e.g. \`${captureDir}/page-home.png\`): the server allows it, and the repository stays clean. Never the \`--output-dir\` option (the server's launch argument, which a session cannot set).`;
 }
 /** Précheck : la session lit le lot dans le plan (Sonnet, qui a la place pour un plan de plusieurs centaines de ko). */
-export const PLAN_READING = 'Read the lot, its notes and sub-tasks in the plan (`.cadence/raf.yaml`, the legacy `docs/plan/raf.yaml`, or the file named by `plan:` in `cadence.yaml`),';
+export const PLAN_READING = 'Read the lot, its notes and sub-tasks in the plan (`.cadence/raf.yaml`, the legacy `docs/plan/raf.yaml`, or the file named by `plan:` in `cadence.yaml`; never read `.cadence/archive/`, the closed lots moved out of the plan),';
 /**
  * Précheck sur le modèle local (L322) : le lot est dans le brief et la session n'ouvre pas le plan. Un plan de 474 ko lu en entier remplissait la fenêtre de 64 k
  * de qwen3-coder:30b (7 « Autocompact is thrashing » sur 32 lots, 23 au 25-10) ; les lectures du dépôt restent courtes pour la même raison.
@@ -109,7 +109,7 @@ export function loadTemplates(dir = TEMPLATES_DIR) {
 export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
     const text = typeof source === 'string' ? loadTemplates(source)[kind] : source[kind];
     const out = text.replace(/\{\{(\w+)\}\}/g, (_m, name) => {
-        const v = { ...vars, repos: vars.repos ?? '', integration: vars.integration ?? '', docs: vars.docs ?? '', elsewhere: vars.elsewhere ?? '', ack: vars.ack ?? '', spec: vars.spec ?? '', decisions: vars.decisions ?? '', accept: vars.accept ?? '', maquette: vars.maquette ?? '', tmp: vars.tmp ?? '', workers: vars.workers ?? '', shots: vars.shots ?? '', fiche: vars.fiche ?? '', lecture: vars.lecture ?? PLAN_READING }[name];
+        const v = { ...vars, repos: vars.repos ?? '', integration: vars.integration ?? '', docs: vars.docs ?? '', elsewhere: vars.elsewhere ?? '', ack: vars.ack ?? '', spec: vars.spec ?? '', decisions: vars.decisions ?? '', accept: vars.accept ?? '', maquette: vars.maquette ?? '', tmp: vars.tmp ?? '', workers: vars.workers ?? '', gate: vars.gate ?? '', shots: vars.shots ?? '', fiche: vars.fiche ?? '', lecture: vars.lecture ?? PLAN_READING }[name];
         if (v === undefined)
             throw new RafError(`gabarit ${FILES[kind]} : valeur manquante pour {{${name}}}`);
         return v;
@@ -117,6 +117,17 @@ export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
     // Un marqueur vide ne laisse pas de trou : lignes vides en double ramenées à une.
     return `${out.replace(/[ \t]+\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim()}\n`;
 }
+/**
+ * Consigne `{{gate}}` (L399) : le programme rejoue après chaque écriture `orchestrate.test` et `orchestrate.build`, pas la commande que la session juge équivalente.
+ * Du 22 au 28-10, des lots annoncés verts arrivaient rouges à la porte parce que la session avait joué `npm run build` (tsconfig.build.json : `src` seul)
+ * alors que la porte joue `npx tsc --noEmit` (test et scripts compris) : L330, L353. Vide sans commande déclarée.
+ */
+export function gateText(gate) {
+    const lines = [gate.test ? `- tests: \`${gate.test}\`` : '', gate.build ? `- build: \`${gate.build}\`` : ''].filter(Boolean);
+    if (!lines.length)
+        return '';
+    return `The program's gate, played after every writing session, is exactly:\n${lines.join('\n')}\nRun these commands as written before reporting, not a narrower one (\`npm run build\` or \`npm test\` may cover less than the gate). A red there sends the lot back to a correction pass even when your own run was green.`;
+}
 /**
  * L'objectif d'un lot (L258) : celui gardé dans l'état du lot (`LotState.goal`, fixé au lancement : `--goal`, sinon la clé `goal:` du plan),
  * sinon son titre. Une seule source pour les briefs, la simulation et le tableau : la clé `goal:` du plan n'est pas relue en cours de vague,

package/dist/orchestrate/command.js

@@ -25,10 +25,10 @@ import { ficheReviewText } from './fiche.js';
 import { maquetteText } from './maquette.js';
 import { costlyHypotheses, specScreen, specText } from './spec.js';
 import { fichesDuDossier } from '../spec.js';
-import { candidates, parsePriority, parseUntil, readPriority, stopReason } from './continue.js';
+import { candidates, parsePriority, parseUntil, drawSettingsReport, readPriority, stopReason } from './continue.js';
 import { precheckNothingToFind, Budget, ESCALATION_RESERVE, DROPPED, STOP_REQUESTED, MAX_PASSES, REVIEW_RESERVE, budgetStep, heldForEscalation, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, planNoteHandBack, leadReviewedHandBack, HYPOTHESES_HANDBACK, handBackDroppedQuestions, needsPrecheck, workDir } from './cycle.js';
 import { canInstallPrePush, gitProcessRunning, indexLockRefusal, installPrePush, longDuration, removePrePush, snapshot } from './guard.js';
-import { buildArgs, buildLocalArgs, killSessions, MODEL_ALIASES, mcpServersFor, readAgents, realClaude } from './launch.js';
+import { buildArgs, buildLocalArgs, killSessions, MODEL_ALIASES, mcpServersFor, readAgents, realClaude, enabledPlugins, settingsFiles } from './launch.js';
 import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
 import { groupLots, runPool } from './pool.js';
 import { repoBranch } from './integrate.js';
@@ -564,7 +564,7 @@ function dryRun(lots, io, deps, budget, id) {
             writeFileSync(file, brief);
             const playwright = !!mcpServersFor(s.kind, l.visible, '', l.small, !!l.screen).playwright;
             const local = s.model === 'local';
-            const args = (local ? buildLocalArgs : buildArgs)({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model === 'local' ? 'sonnet' : s.model, local, effort: env.config.effort[s.kind === 'review-small' ? 'review' : s.kind], schema: schemaFor(s.kind), agent: s.kind === 'implement' ? undefined : s.kind === 'spec' ? 'spec-writer' : s.kind === 'accept' ? 'acceptance-writer' : s.kind === 'ux' || s.kind === 'maquette' ? 'ux-reviewer' : s.kind === 'precheck' ? 'precheck-reader' : 'code-reviewer', cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && (s.kind === 'implement' || s.kind === 'spec') ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
+            const args = (local ? buildLocalArgs : buildArgs)({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model === 'local' ? 'sonnet' : s.model, local, effort: env.config.effort[s.kind === 'review-small' ? 'review' : s.kind], schema: schemaFor(s.kind), agent: s.kind === 'implement' ? undefined : s.kind === 'spec' ? 'spec-writer' : s.kind === 'accept' ? 'acceptance-writer' : s.kind === 'ux' || s.kind === 'maquette' ? 'ux-reviewer' : s.kind === 'precheck' ? 'precheck-reader' : 'code-reviewer', cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && (s.kind === 'implement' || s.kind === 'spec') ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright, disablePlugins: enabledPlugins(settingsFiles(deps.claudeHome, l.repo)) }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
             io.out(`  ${s.kind} : ${local ? 'claude-local' : 'claude'} ${args.join(' ')}`);
             io.out(`    brief : ${file}`);
             const servers = Object.keys(mcpServersFor(s.kind, l.visible, '', l.small, !!l.screen));
@@ -627,18 +627,25 @@ const CLEAR_SCREEN = '\x1b[H\x1b[2J';
 const DEFAULT_WATCH_INTERVAL = 10;
 /** Ce que `--status` montre à un instant : les vagues vivantes, puis le tableau (absent si seules les vagues vivantes comptent). */
 function statusView(args, launch, cap, now) {
-    const store = typeof args.status === 'string' ? RunStore.find(launch, args.status) : RunStore.last(launch);
+    const id = statusWave(args);
+    const store = id !== undefined ? RunStore.find(launch, id) : RunStore.last(launch);
     const live = [...liveLines(cap, now), ...expiredHoldLines(now)];
     const waveLive = liveWaves(cadenceHome()).length > 0;
-    if (!store && live.length && args.status === true)
+    if (!store && live.length && id === undefined)
         return { live, running: waveLive };
     if (!store)
-        throw new RafError(typeof args.status === 'string' ? `vague inconnue : ${args.status}` : 'aucune vague dans ce dossier');
+        throw new RafError(id !== undefined ? `vague inconnue : ${id}` : 'aucune vague dans ce dossier');
     // `running` : la vague suivie tourne — pour un <id> explicite, elle seule compte, pas les autres vagues de la machine
-    const running = typeof args.status === 'string' ? liveWaves(cadenceHome()).some((w) => w.wave === store.readWave().id) : waveLive;
+    const running = id !== undefined ? liveWaves(cadenceHome()).some((w) => w.wave === store.readWave().id) : waveLive;
     const lots = store.lots();
     return { live, table: [...renderTable(store.readWave(), lots), ...keptLines(lots.map((l) => l.repo), now.getTime())], running };
 }
+/** La vague que `--status` suit (L395) : `--status <id>` ou `--status --wave <id>` ; aucune : la dernière du dossier. Deux ids différents : refus. */
+function statusWave(args) {
+    if (typeof args.status === 'string' && args.wave !== undefined && args.status !== args.wave)
+        throw new RafError(`--status ${args.status} et --wave ${args.wave} désignent deux vagues : une seule`);
+    return typeof args.status === 'string' ? args.status : args.status === true ? args.wave : undefined;
+}
 /** Refus d'une `--wave` déjà existante, identique en simulation et au vrai lancement. */
 function waveExists(wave, io) {
     io.err(`orchestrate : --wave ${wave} : cette vague existe déjà`);
@@ -955,6 +962,8 @@ async function continueDryRun(args, io, deps, launch, given, budget, firstSkippe
     };
     skip(firstSkipped);
     const exclude = new Set(given.map((l) => lotKey(l.project, l.lot)));
+    for (const line of drawSettingsReport(launch, exclude))
+        io.out(`  ${line}`);
     let remaining = budget - given.reduce((sum, l) => sum + (l.budget ?? 0), 0);
     const cap = maxSessions(args, io);
     const rounds = [];
@@ -1145,7 +1154,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
                     return DROPPED;
                 return ctl.stopAfterCurrent ? STOP_REQUESTED : null;
             },
-            onWait: (h, ms) => wctx.log(`${o.lot ? `${o.lot} · ` : ''}en attente d'un créneau de session depuis ${duration(ms)} (${h.length}/${cap} en cours : ${[...new Set(h.map((x) => x.wave))].join(', ')})`),
+            onWait: (h, ms, limit) => wctx.log(`${o.lot ? `${o.lot} · ` : ''}en attente d'un créneau de session depuis ${duration(ms)} (${h.length}/${limit} en cours : ${[...new Set(h.map((x) => x.wave))].join(', ')})`),
             onGot: (ms) => wctx.log(`${o.lot ? `${o.lot} · ` : ''}créneau de session obtenu après ${duration(ms)} d'attente`),
         });
         try {

package/dist/orchestrate/continue.js

@@ -55,8 +55,22 @@ export function priorityRank(project, priority) {
 export function decisionPending(lot) {
     return /à décider/i.test([lot.title, ...lot.notes.map((n) => n.text)].join('\n'));
 }
+/** Un lot marqué « non tirable » (titre ou note) n'est jamais tiré par `--continue` (L390) ; il reste lançable à la main. */
+export function nonDrawable(lot) {
+    return /non tirable/i.test([lot.title, ...lot.notes.map((n) => n.text)].join('\n'));
+}
+/** Pourquoi le réglage `orchestrate.continue` du projet (et le marqueur « non tirable ») écarte ce lot du tirage, ou null quand il reste tirable (L390). */
+export function drawFilter(lot, setting) {
+    if (setting?.exclude?.includes(lot.id))
+        return 'listé dans continue.exclude';
+    if (nonDrawable(lot))
+        return 'marqué « non tirable »';
+    if (setting?.maxEstimate !== undefined && lot.estimate !== undefined && lot.estimate > setting.maxEstimate)
+        return `estimate ${lot.estimate} > continue.maxEstimate ${setting.maxEstimate}`;
+    return null;
+}
 /**
- * Les lots tirables sous `launch` : prêts (à faire, `after` levé, ni récurrents ni en cours), ni « à décider avec Sylvain » ni déjà
+ * Les lots tirables sous `launch` : prêts (à faire, `after` levé, ni récurrents ni en cours), ni « à décider avec Sylvain », ni écartés par le réglage `orchestrate.continue` du projet ou marqués « non tirable » (L390), ni déjà
  * dans la vague, dont le budget tient dans `remaining` ; projets dans l'ordre de priorité (puis alphabétique), lots dans l'ordre du plan
  * (gains rapides d'abord). `launch` est un projet : lui seul ; sinon ses sous-dossiers qui en sont. Un plan illisible est sauté.
  */
@@ -74,22 +88,53 @@ export function candidates(launch, o) {
         }
         let specDir = 'docs/specs';
         let escalating = false;
+        let setting;
         try {
             const config = projectEnv(dir).config;
             specDir = config.spec.dir;
             escalating = !!config.escalation;
+            setting = config.continue;
         }
         catch {
             // configuration illisible : le dossier par défaut
         }
         for (const lot of ready) {
-            if (o.exclude.has(`${project}:${lot.id}`) || decisionPending(lot) || lotBudget(lot.estimate, specScreen(dir, specDir, lot) ? 'screen' : lot.spec ? 'spec' : undefined, escalating) > o.remaining)
+            if (o.exclude.has(`${project}:${lot.id}`) || decisionPending(lot))
+                continue;
+            const why = drawFilter(lot, setting);
+            if (why) {
+                o.skipped?.push(`${project}:${lot.id} écarté du tirage : ${why}`);
+                continue;
+            }
+            if (lotBudget(lot.estimate, specScreen(dir, specDir, lot) ? 'screen' : lot.spec ? 'spec' : undefined, escalating) > o.remaining)
                 continue;
             out.push({ project, dir, lot });
         }
     }
     return out;
 }
+/**
+ * Pour `--dry-run --continue` (L390) : une ligne par projet qui règle son tirage (`réglage de tirage — <projet> : maxEstimate 1, exclude L3`),
+ * puis une par lot prêt que ce réglage écarte (hors lots déjà dans `exclude`, donnés à la main : ceux-là se jouent).
+ */
+export function drawSettingsReport(launch, exclude) {
+    const dirs = isProject(launch) ? [launch] : findProjects(launch);
+    const lines = [];
+    for (const dir of dirs) {
+        try {
+            const setting = projectEnv(dir).config.continue;
+            const parts = [setting?.maxEstimate !== undefined ? `maxEstimate ${setting.maxEstimate}` : '', setting?.exclude?.length ? `exclude ${setting.exclude.join(' ')}` : ''].filter(Boolean);
+            if (parts.length)
+                lines.push(`réglage de tirage — ${basename(dir)} : ${parts.join(', ')}`);
+        }
+        catch {
+            // configuration illisible : le projet est signalé par ailleurs
+        }
+    }
+    const skipped = [];
+    candidates(launch, { priority: [], exclude, remaining: Infinity, skipped });
+    return [...lines, ...skipped.map((s) => `lot écarté — ${s}`)];
+}
 /** Pourquoi la vague ne tire plus de lot, ou null quand elle peut continuer. */
 export function stopReason(f) {
     if (f.stopRequested)