@sylad/cadence 1.17.1 → 1.19.0

package/dist/orchestrate/cycle.js

@@ -19,9 +19,9 @@ import { isPlanOnly } from '../audit.js';
 import { compareBaseline, failedTests, hasUnnamedFailure } from './baseline.js';
 import { replayRed, TEST_WORKERS_ENV, testWorkersText } from './workers.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
-import { capturesText, headline, integrationText, localReading, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, tmpText } from './briefs.js';
+import { capturesText, gateText, 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 { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, trackGroup, writeMcpConfig, enabledPlugins, settingsFiles } from './launch.js';
 import { cleanPlaywrightOutput, pushed, remoteAdvances, snapshot } from './guard.js';
 import { sumTokens } from './result.js';
 import { cutReport, EXTENSION_MS, MAX_EXTENSIONS, workTimeoutMs } from './timeouts.js';
@@ -147,8 +147,11 @@ async function commitPlan(c, message, root = c.lot.repo, before = new Map()) {
     const repo = root;
     const ownFile = planOwnFile(c, repo);
     // Les fichiers de plan.onWrite (L346) entrent même non suivis : le premier plan publié n'est pas encore au dépôt.
-    const produced = c.loadPlan().produced;
-    const dirty = [...new Set([...trackedPaths(await snapshot(repo, { remote: false })), ...dirtyPaths(repo, produced)])];
+    // Les fichiers d'année de l'archive (L396) aussi : un `raf archive` non commité pendant la vague les crée ou les réécrit, et le plan seul commité laisserait HEAD sans les lots archivés.
+    // Chemins relatifs au dépôt du projet (comme `plan.maintained`), même quand `root` est un worktree de lot ; vide pour un plan en lecture seule.
+    const plan = c.loadPlan();
+    const archives = plan.archiveFiles().map((f) => relative(c.lot.repo, f));
+    const dirty = [...new Set([...trackedPaths(await snapshot(repo, { remote: false })), ...dirtyPaths(repo, [...plan.produced, ...archives])])];
     if (dirty.length === 0)
         return null;
     const foreign = dirty.filter((f) => !ownFile(f));
@@ -488,7 +491,7 @@ 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: kind === 'implement' || kind === 'fix' ? workersText(c) : '', 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: '', tmp: tmpText(tmpDir), workers: kind === 'implement' || kind === 'fix' ? workersText(c) : '', gate: kind === 'implement' || kind === 'fix' ? 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);
@@ -746,6 +749,7 @@ async function session(c, kind, local = false) {
         tmpDir,
         mcpConfig,
         playwright,
+        disablePlugins: enabledPlugins(settingsFiles(w.claudeHome, wd(c))),
         timeoutMs: delay,
         extend,
     }, {
@@ -1970,10 +1974,22 @@ async function acceptGreen(c) {
  * (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) {
+    try {
+        await runChecks(c, red, runs);
+    }
+    finally {
+        // L395 : la porte se lit dans l'état du lot tant qu'une commande (ou le rejeu qui la suit) tourne, jamais après.
+        c.lot.gate = undefined;
+        save(c);
+    }
+}
+async function runChecks(c, red, runs) {
     const l = c.lot;
     for (const [label, command] of [['build', c.config.build], ['tests', c.config.test]]) {
         if (!command)
             continue;
+        l.gate = { label, started: new Date().toISOString() };
+        save(c);
         const r = await sh(c, command);
         const run = { label, command, code: r.code };
         runs.push(run);
@@ -2285,7 +2301,7 @@ async function work(c, kind) {
         }
     }
     l.constats = [];
-    l.checks = runs.length ? { head: git(wd(c), 'rev-parse', 'HEAD'), runs } : undefined;
+    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);
 }
@@ -2749,7 +2765,7 @@ async function integrateLot(c) {
                 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, runs } = await integratedChecks(c, key);
-                    l.checks = runs.length ? { head: tip, runs } : undefined;
+                    l.checks = runs.length ? { head: tip, tree: git(t.dir, 'rev-parse', 'HEAD^{tree}'), runs } : undefined;
                     save(c);
                     if (red.length)
                         return refuse(`intégration refusée : tests rouges au sommet intégré (${red.map(redExcerpt).join(' ; ')}) ; branche du dépôt inchangée, ${kept}`);

package/dist/orchestrate/launch.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { delimiter, join, resolve } from 'node:path';
 import { parse } from 'yaml';
 import { RafError } from '../plan.js';
@@ -54,6 +55,39 @@ function effortArgs(spec) {
 }
 /** Retire `run_in_background` de Bash et des sous-agents : `claude -p` attend toute tâche de fond avant de sortir (jusqu'à 10 min d'inactivité), la session finie ne rendait pas la main (L285). */
 export const NO_BACKGROUND_ENV = { CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: '1' };
+/** Dossier de Claude Code de l'utilisateur : `CLAUDE_CONFIG_DIR`, sinon `~/.claude` (le `HOME` de l'environnement donné : les tests en simulent un). */
+export function claudeConfigDir(env = process.env) {
+    return env.CLAUDE_CONFIG_DIR || join(env.HOME || homedir(), '.claude');
+}
+/** Les fichiers de réglages dont les plugins activés comptent pour une session lancée dans `cwd` : celui de l'utilisateur (`claudeHome`, s'il est connu), ceux du projet et du dossier. */
+export function settingsFiles(claudeHome, cwd) {
+    return [...(claudeHome ? [join(claudeHome, 'settings.json')] : []), join(cwd, '.claude', 'settings.json'), join(cwd, '.claude', 'settings.local.json')];
+}
+/** Identifiants des plugins activés (`enabledPlugins: { "<id>": true }`) dans l'un des fichiers de réglages donnés ; un fichier absent ou illisible ne compte pas. */
+export function enabledPlugins(files) {
+    const ids = new Set();
+    for (const file of files) {
+        let settings;
+        try {
+            settings = JSON.parse(readFileSync(file, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        for (const [id, on] of Object.entries(settings?.enabledPlugins ?? {}))
+            if (on === true)
+                ids.add(id);
+    }
+    return [...ids];
+}
+/**
+ * `--settings` d'une session (L398) : un JSON qui ne porte que les plugins de l'utilisateur et du projet à `false`. Un plugin désactivé n'enregistre
+ * ni ses hooks (celui de démarrage de superpowers injectait 3,4 ko) ni ses skills : le contexte qu'une session, qui n'en appelle aucun, ne paie plus
+ * (mesure : `docs/mesures/contexte-session-2026-10-28.md`). Rien d'autre n'est touché ni relayé : les réglages de l'utilisateur et du projet
+ * s'appliquent avec leur précédence normale (`--settings` l'emporte sur un projet qui active le plugin, vérifié le 2026-10-28), ses hooks compris.
+ * En argument, pas dans un fichier : des identifiants seulement (`nom@marketplace`, aucun secret), 1 000 plugins pèsent 50 ko sous la limite d'un argument Linux (128 ko).
+ */
+const settingsArgs = (spec) => (spec.disablePlugins?.length ? ['--settings', JSON.stringify({ enabledPlugins: Object.fromEntries(spec.disablePlugins.map((id) => [id, false])) })] : []);
 export function buildArgs(spec, agents) {
     const args = ['-p', spec.brief, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model, ...effortArgs(spec)];
     if (spec.agent) {
@@ -64,7 +98,7 @@ export function buildArgs(spec, agents) {
     args.push('--session-id', spec.sessionId, '--permission-mode', spec.permissionMode);
     for (const d of spec.addDirs)
         args.push('--add-dir', d);
-    args.push('--disallowedTools', ...DISALLOWED);
+    args.push(...settingsArgs(spec), '--disallowedTools', ...DISALLOWED);
     if (spec.mcpConfig)
         args.push('--strict-mcp-config', '--mcp-config', spec.mcpConfig);
     return args;
@@ -126,7 +160,7 @@ export function buildRetryArgs(spec, sessionId, agents) {
     args.push('--resume', sessionId, '--permission-mode', spec.permissionMode);
     for (const d of spec.addDirs)
         args.push('--add-dir', d);
-    args.push('--disallowedTools', ...DISALLOWED);
+    args.push(...settingsArgs(spec), '--disallowedTools', ...DISALLOWED);
     if (spec.mcpConfig)
         args.push('--strict-mcp-config', '--mcp-config', spec.mcpConfig);
     return args;

package/dist/orchestrate/registry.js

@@ -49,14 +49,24 @@ export function liveWaves(home) {
     }
     return out.sort((a, b) => a.started.localeCompare(b.started));
 }
+/**
+ * Le plafond que TOUTES les vagues vivantes appliquent (L395) : le plus bas des plafonds connus, `fallback` si aucune n'en déclare.
+ * Les créneaux sont communs : deux plafonds différents ne peuvent pas être respectés tous les deux (une vague à 4 à côté d'une
+ * vague à 3 portait le total à « 4/3 » et la vague à 3 attendait), le plus bas fait loi pour toutes.
+ */
+export function commonCap(waves, fallback) {
+    const caps = waves.map((w) => w.cap).filter((c) => c !== undefined && Number.isFinite(c) && c >= 1);
+    return caps.length ? Math.min(fallback, ...caps) : fallback;
+}
 /**
  * Les créneaux que le lead peut encore donner à des sous-agents : `total` moins, pour chaque vague vivante, le
- * plus petit de son plafond et du nombre de lots qu'elle joue à la fois — un par dépôt qu'elle tient encore, un par lot pour des lots en worktrees (ses pas prennent un créneau et le
+ * plus petit du plafond commun (`commonCap`) et du nombre de lots qu'elle joue à la fois — un par dépôt qu'elle tient encore, un par lot pour des lots en worktrees (ses pas prennent un créneau et le
  * rendent entre deux étapes : les sessions vivantes à l'instant ne disent pas ce que la vague va reprendre).
  * Une vague sans plafond connu compte pour `total`.
  */
 export function freeSlots(waves, total, leadSessions = 0) {
-    const held = waves.reduce((n, w) => n + Math.min(w.cap ?? total, w.lanes ?? w.repos.length), 0);
+    const common = commonCap(waves, total);
+    const held = waves.reduce((n, w) => n + Math.min(w.cap !== undefined ? common : total, w.lanes ?? w.repos.length), 0);
     return Math.max(0, total - held - leadSessions);
 }
 const holdsDir = (home) => join(home, 'holds');
@@ -182,9 +192,9 @@ export class SlotAbandoned extends Error {
 }
 /**
  * Attend que le nombre de sessions vivantes, TOUTES vagues confondues et quel que soit l'index de leur créneau,
- * soit sous `cap` (le plafond de cette vague), puis prend le premier créneau libre (un pid mort est repris) et
- * rend sa libération. Chaque vague applique SON plafond au total commun : avec des plafonds différents, la
- * vague au plafond le plus haut peut porter le total au-dessus du plafond de l'autre, qui attend alors.
+ * soit sous le plafond commun — `cap` (le plafond de cette vague) ou, s'il est plus bas, celui d'une autre vague vivante
+ * (`commonCap`, relu à chaque tour, L395) —, puis prend le premier créneau libre (un pid mort est repris) et
+ * rend sa libération. Toutes les vagues appliquent le même plafond : jamais « 4/3 en cours ».
  * Deux vagues qui prennent en même temps se départagent au recomptage : si le total dépasse `cap` une fois
  * le créneau pris, il est rendu et l'attente reprend.
  *
@@ -208,15 +218,16 @@ export async function acquireSlot(home, cap, opts) {
             throw new SlotAbandoned(why);
     };
     for (;;) {
+        const limit = commonCap(liveWaves(home), cap); // relu à chaque tour : une vague au plafond bas qui s'arrête le relève
         if (reportedAt !== null)
             checkAbandon(); // pas à la première tentative : un créneau libre est pris même si une demande est posée
-        if (live(home).length < cap) {
+        if (live(home).length < limit) {
             for (let k = 0; k < MAX_SLOT_INDEX; k++) {
                 const file = join(slotsDir(home), `slot-${k}.lock`);
                 const got = takeLock(file, { pid: process.pid, wave: opts.wave, started: new Date().toISOString() });
                 if (!got.ok)
                     continue;
-                if (live(home).length <= cap) {
+                if (live(home).length <= limit) {
                     if (reportedAt !== null)
                         opts.onGot?.(now() - t0);
                     return () => releaseLock(file, process.pid);
@@ -229,7 +240,7 @@ export async function acquireSlot(home, cap, opts) {
             checkAbandon(); // la première tentative a échoué : l'attente commence, la demande déjà posée l'interrompt sans attendre un tour
         if (reportedAt === null || now() - reportedAt >= (opts.reportMs ?? WAIT_REPORT_MS)) {
             reportedAt = now();
-            opts.onWait?.(live(home), reportedAt - t0);
+            opts.onWait?.(live(home), reportedAt - t0, limit);
         }
         await new Promise((r) => setTimeout(r, pollMs + Math.random() * pollMs * 0.25));
     }

package/dist/orchestrate/table.js

@@ -64,6 +64,13 @@ function ux(l) {
 }
 const commits = (l) => new Set(l.steps.flatMap((s) => s.commits ?? [])).size;
 const counted = (l) => l.steps.reduce((n, s) => n + (s.tokens?.counted ?? 0), 0);
+/** L'état d'un lot (L395) : « porte tests (3 min) » tant que la commande de la porte du programme tourne dans une vague vivante, sinon l'étiquette de son statut. Une porte restée dans l'état d'une vague arrêtée (processus tué) ne tourne plus. */
+const stateText = (l, wave, now) => {
+    if (!l.gate || wave.status !== 'running')
+        return LABEL[l.status];
+    const since = Date.parse(l.gate.started);
+    return `porte ${l.gate.label}${Number.isFinite(since) ? ` (${Math.max(0, Math.floor((now - since) / 60_000))} min)` : ''}`;
+};
 const minutes = (l) => Math.round(l.steps.reduce((n, s) => n + (s.ended ? Date.parse(s.ended) - Date.parse(s.started) : 0), 0) / 60_000);
 /** Sha abrégés (7, comme `short` du cycle) des commits que git attribue au lot dans son dépôt, du plus ancien au plus récent (illisible ou sans plan : aucun). */
 function gitCommitsOf(l) {
@@ -189,7 +196,7 @@ export function resumeAnswerHint(waveId, l) {
 }
 /** Le tableau de fin de vague (ou de `--status`), une ligne par lot puis le total et les questions. */
 export function renderTable(wave, lots, deps = {}) {
-    const rows = lots.map((l) => [`${l.project}:${l.lot}`, LABEL[l.status], String(l.pass), review(l), ux(l), String(commits(l)), k(counted(l)), `${minutes(l)} min`]);
+    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 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();

package/dist/orchestrate/worktree.js

@@ -1,6 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, rmSync, symlinkSync, realpathSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, readdirSync, rmSync, symlinkSync, realpathSync } from 'node:fs';
+import { cp, readdir, realpath, rm, symlink } from 'node:fs/promises';
 import { basename, dirname, isAbsolute, join, relative, sep } from 'node:path';
 import { lotSlug } from './state.js';
 import { cadenceHome, liveWaves } from './registry.js';
@@ -129,44 +130,58 @@ export function linkIgnored(repo, dir) {
 export function ignoredDeps(repo) {
     return git(repo, 'ls-files', '--others', '--ignored', '--exclude-standard', '--directory').split('\n').map((f) => f.replace(/\/$/, '')).filter((f) => f && !f.startsWith('.cadence') && !f.split('/').some((p) => OUTPUT_DIRS.has(p)));
 }
+/** Les dépendances que `verify --gate` copie quand `orchestrate.worktreeDeps` est absente (L392) : les `node_modules` de tout niveau et le `.venv`. Rien d'autre (données, `.env`) : trop gros, ou secret. */
+export const isCopiedDep = (name) => ['node_modules', '.venv'].includes(basename(name));
 /**
  * Copie dans le worktree `dir` ces dépendances du dépôt vivant (L389), au lieu de les y relier : un outil qui refuse de charger un `node_modules` lié depuis
- * un autre arbre (Astro : « Could not load … ») les trouve chez lui. Les liens relatifs du dossier qui restent dans le dépôt (espaces de travail) sont
- * copiés tels quels : ils pointent dans la copie. Ceux qui en sortent (`file:../voisin`, `link:`) pointeraient dans le vide depuis `dir` : ils sont refaits
- * vers leur cible vivante. Rend les chemins copiés ; un chemin dont le parent n'existe pas dans le worktree est passé.
+ * un autre arbre (Astro : « Could not load … ») les trouve chez lui. Asynchrone (L392) : une copie synchrone de plusieurs centaines de Mo figerait la boucle
+ * d'événements, et le Ctrl-C reçu pendant ce temps n'aurait aucun effet. Un dossier qui est lui-même un lien est copié par son contenu (copier le lien ne
+ * copierait rien). Les liens relatifs du dossier qui restent dans le dépôt (espaces de travail) sont copiés tels quels : ils pointent dans la copie. Ceux qui en
+ * sortent (`file:../voisin`, `link:`) pointeraient dans le vide depuis `dir` : ils sont refaits vers leur cible vivante. Rend les chemins copiés ;
+ * un chemin dont le parent n'existe pas dans le worktree est passé.
  */
-export function copyDeps(repo, dir, names) {
+export async function copyDeps(repo, dir, names) {
     const copied = [];
+    const repoReal = realpathSync(repo);
     for (const name of names) {
         const to = join(dir, name);
         if (existsSync(to) || !existsSync(dirname(to)))
             continue;
-        cpSync(join(repo, name), to, { recursive: true, verbatimSymlinks: true });
-        relinkOutside(realpathSync(repo), join(repo, name), to);
+        let from = join(repo, name);
+        try {
+            from = realpathSync(from);
+        }
+        catch {
+            continue; // lien mort : rien à copier
+        }
+        await cp(from, to, { recursive: true, verbatimSymlinks: true });
+        // Un dossier venu d'hors du dépôt (lien) garde ses liens internes relatifs ; ses liens vers le reste du monde sont refaits vers leur cible vivante.
+        const inside = !relative(repoReal, from).startsWith('..');
+        await relinkOutside(inside ? repoReal : from, from, to);
         copied.push(name);
     }
     return copied;
 }
-/** Dans la copie `to` de `live`, refait vers leur cible vivante les liens relatifs dont la cible sort du dépôt `repoReal`. */
-function relinkOutside(repoReal, live, to) {
-    for (const e of readdirSync(live, { withFileTypes: true })) {
-        const liveEntry = join(live, e.name);
+/** Dans la copie `to` du dossier de vrai chemin `real`, refait vers leur cible vivante les liens dont la cible sort de `boundary`. */
+async function relinkOutside(boundary, real, to) {
+    for (const e of await readdir(real, { withFileTypes: true })) {
+        const realEntry = join(real, e.name);
         const copy = join(to, e.name);
         if (e.isSymbolicLink()) {
-            let real;
+            let target;
             try {
-                real = realpathSync(liveEntry);
+                target = await realpath(realEntry);
             }
             catch {
                 continue; // lien mort : recopié tel quel
             }
-            if (relative(repoReal, real).startsWith('..')) {
-                rmSync(copy);
-                symlinkSync(real, copy);
+            if (relative(boundary, target).startsWith('..')) {
+                await rm(copy);
+                await symlink(target, copy);
             }
         }
         else if (e.isDirectory()) {
-            relinkOutside(repoReal, liveEntry, copy);
+            await relinkOutside(boundary, realEntry, copy);
         }
     }
 }
@@ -271,10 +286,10 @@ export function recoverTree(repo, branch, dir, base, planFiles = new Set()) {
     }
     return { from: found.branch, unintegrated: found.unintegrated };
 }
-/** Les fichiers du plan qu'une session ne doit pas toucher, relatifs au dépôt : le fichier de plan, la page Gantt et ce qui est généré avec (`plan.files`, les fichiers de `plan.onWrite`). */
+/** Les fichiers du plan qu'une session ne doit pas toucher, relatifs au dépôt : le fichier de plan, la page Gantt, ce qui est généré avec (`plan.files`, les fichiers de `plan.onWrite`) et les fichiers d'année de l'archive (L396). */
 export function planFileSet(plan, repo) {
     const rel = relative(repo, plan.path);
-    return new Set([rel, join(dirname(rel), 'gantt.html'), ...plan.files, ...plan.produced]);
+    return new Set([rel, join(dirname(rel), 'gantt.html'), ...plan.files, ...plan.produced, ...plan.archiveFiles().map((f) => relative(repo, f))]);
 }
 /** Les commits de la branche du lot déjà dans la branche du dépôt ? */
 export function integrated(repo, branch, base) {

package/dist/plan-commit.js

@@ -18,6 +18,8 @@ export const PLAN_ACTIONS = {
     minors: (label) => `mineurs de la revue de ${label} notés`,
     /** `raf done` ne commite pas : l'action de la commande de commit qu'il propose (L371). */
     done: 'terminé',
+    /** `raf archive` (L396) : le nombre de lots déplacés dans l'archive. */
+    archived: (n) => `${n} lot(s) archivé(s)`,
     reviewRecorded: 'revue de code enregistrée',
     reviewNoted: 'revue de code notée',
     /** `cadence deliver` pendant une vague (L388) : le lot de l'article ouvert, ou ses titres ajoutés en note. */