@sylad/cadence 1.39.0 → 1.41.0

package/dist/memory-index.js

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse } from 'yaml';
+import { RafError } from './plan.js';
+import { claudeConfigDir, projectLogDir } from './orchestrate/launch.js';
+/** Taille (octets) au-delà de laquelle l'index MEMORY.md est signalé quand `memory.indexMaxBytes` n'est pas posé (L442). */
+const MEMORY_INDEX_MAX_BYTES = 12_000;
+/** L'index de la mémoire de Claude Code du dossier `dir` (celui où la session est lancée, jamais la racine git). */
+function memoryIndexPath(env, dir) {
+    return join(projectLogDir(claudeConfigDir(env), dir), 'memory', 'MEMORY.md');
+}
+// « - », puis au plus « ** », « [ » et « ⚠ », puis un jour « jj-mm » : le nom du fichier lié ne compte pas.
+const DATED = /^- (?:\*\*)?\[?(?:⚠️?\s*)?(?:0[1-9]|[12]\d|3[01])-(?:0[1-9]|1[0-2])(?!\d)/;
+/** Les entrées datées d'un index : leur nombre et leur poids en octets (fin de ligne comprise). */
+function datedEntries(text) {
+    let count = 0;
+    let bytes = 0;
+    const lines = text.replace(/^\uFEFF/, '').split('\n');
+    for (const [i, line] of lines.entries()) {
+        const bare = line.replace(/\r$/, '');
+        if (!DATED.test(bare))
+            continue;
+        count++;
+        // la fin de ligne ne compte que si elle existe : la dernière ligne peut ne pas en avoir
+        bytes += Buffer.byteLength(line) + (i < lines.length - 1 ? 1 : 0);
+    }
+    return { count, bytes };
+}
+/** Mesure l'index : absent ou au plus égal au seuil = `ok` ; une lecture impossible se dit au lieu de lever. Ne modifie rien. */
+function checkMemoryIndex(env, dir, max) {
+    let buf;
+    try {
+        buf = readFileSync(memoryIndexPath(env, dir));
+    }
+    catch (e) {
+        const code = e.code;
+        return code === 'ENOENT' ? { kind: 'ok' } : { kind: 'unreadable', cause: e.message.split('\n')[0] };
+    }
+    if (buf.length <= max)
+        return { kind: 'ok' };
+    return { kind: 'over', size: buf.length, max, ...datedEntries(buf.toString('utf8')) };
+}
+const NO_DATED = "aucune entrée datée à regrouper dans l'index MEMORY.md";
+/** Les lignes de la section « Mémoire » de `session close`, précédée d'une ligne vide (aucune quand l'index est sain). */
+function closeLines(c) {
+    if (c.kind === 'ok')
+        return [];
+    if (c.kind === 'unreadable')
+        return [`\nMémoire : l'index MEMORY.md est illisible (${c.cause}), sa taille n'est pas contrôlée`];
+    return [
+        `\nMémoire : l'index MEMORY.md pèse ${c.size} octets (seuil ${c.max})`,
+        c.count === 0
+            ? `  ${NO_DATED}`
+            : `  ${c.count} entrée(s) datée(s) (${c.bytes} octets) à regrouper sous une ligne vers un index secondaire — le skill propose, l'humain décide`,
+    ];
+}
+function tourLines(c) {
+    if (c.kind === 'ok')
+        return [];
+    if (c.kind === 'unreadable')
+        return [`mémoire · MEMORY.md illisible (${c.cause})`];
+    const tail = c.count === 0 ? 'aucune entrée datée à regrouper' : `${c.count} entrée(s) datée(s) à regrouper (cadence session close détaille)`;
+    return [`mémoire · MEMORY.md ${c.size} octets > seuil ${c.max} · ${tail}`];
+}
+/**
+ * Clé `memory.indexMaxBytes` de cadence.yaml : seuil, en octets, de l'avertissement ; `undefined` quand elle est absente.
+ * Une valeur qui n'est pas un entier ≥ 1 est refusée.
+ */
+export function readMemoryIndexMax(file) {
+    if (!existsSync(file))
+        return undefined;
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const m = raw?.memory;
+    if (m == null)
+        return undefined;
+    if (typeof m !== 'object' || Array.isArray(m))
+        throw new RafError(`${file} : memory doit être un objet { indexMaxBytes }`);
+    for (const k of Object.keys(m))
+        if (k !== 'indexMaxBytes')
+            throw new RafError(`${file} : memory.${k} inconnu (attendu : indexMaxBytes)`);
+    const v = m.indexMaxBytes;
+    if (v === undefined)
+        return undefined;
+    if (typeof v !== 'number' || !Number.isInteger(v) || v < 1)
+        throw new RafError(`${file} : memory.indexMaxBytes doit être un entier ≥ 1 (octets), pas ${typeof v === 'object' ? JSON.stringify(v) : String(v)}`);
+    return v;
+}
+/**
+ * Pour `session close` : le contexte de la mesure, relu à l'appel (une clé invalide lève alors avant tout rapport). Le seuil vient
+ * du `cadence.yaml` que la commande lit.
+ */
+export function closeMemoryLines(env, dir, configFile) {
+    return () => closeLines(checkMemoryIndex(env, dir, readMemoryIndexMax(configFile) ?? MEMORY_INDEX_MAX_BYTES));
+}
+/**
+ * Pour `lead tour` : la ligne « mémoire » du dossier parent, avec le seuil de son cadence.yaml. Une clé invalide n'arrête pas le tour : une ligne d'erreur
+ * remplace la ligne « mémoire » ; un cadence.yaml illisible a déjà sa ligne d'erreur en tête de tour et n'en ajoute pas ici.
+ */
+export function tourMemoryLines(env, parent) {
+    try {
+        return tourLines(checkMemoryIndex(env, parent, readMemoryIndexMax(join(parent, 'cadence.yaml')) ?? MEMORY_INDEX_MAX_BYTES));
+    }
+    catch (e) {
+        const message = e.message;
+        return / : memory/.test(message) ? [`cadence.yaml · ✗ erreur : ${message.replace(/^.*cadence\.yaml : /, '')}`] : [];
+    }
+}

package/dist/orchestrate/command.js

@@ -24,7 +24,7 @@ import { acceptationFile, acceptText, redAcceptations } from './accept.js';
 import { noTestGate, noTestText } from './no-test.js';
 import { ficheReviewText } from './fiche.js';
 import { maquetteText } from './maquette.js';
-import { costlyHypotheses, specScreen, specText } from './spec.js';
+import { budgetStage, costlyHypotheses, lightLot, specText, stageScreen } from './spec.js';
 import { fichesDuDossier } from '../spec.js';
 import { candidates, fillTargets, handedBackStreak, 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';
@@ -320,7 +320,7 @@ export async function preflight(args, targets, io, deps, launch, opts = {}) {
         }
         const small = lot.estimate <= 0.5 || lot.quickwin;
         const goal = args.goal ?? lot.goal;
-        const screen = specScreen(t.repo, env.config.spec.dir, lot);
+        const screen = stageScreen(t.repo, env.config.spec.dir, lot, env.config.maquette);
         const state = newLot({ project: t.project, repo: t.repo, lot: t.lot, title: lot.title, ...(goal ? { goal } : {}), visible: lot.visible, small, ...(screen ? { screen } : {}), ...(lot.spec && !screen ? { specLot: true } : {}), model: t.model, readOnlyPlan: plan.readonly });
         if (neighbours.repos.length)
             state.repos = neighbours.repos;
@@ -329,7 +329,7 @@ export async function preflight(args, targets, io, deps, launch, opts = {}) {
             state.express = true;
         state.light = lot.estimate <= env.config.review.threshold;
         const escalating = !!env.config.escalation;
-        state.budget = lotBudget(lot.estimate, screen ? 'screen' : lot.spec ? 'spec' : undefined, escalating);
+        state.budget = lotBudget(lot.estimate, budgetStage(lot, screen, env.config.maquette, t.repo, env.config.spec.dir), escalating);
         if (escalating)
             state.escalationReserve = ESCALATION_RESERVE;
         state.dependsOn = lot.after.filter((d) => earlier.includes(d));
@@ -442,7 +442,7 @@ function dryRun(lots, io, deps, { budget, id, multiSlot }) {
         io.out(`${lotKey(l.project, l.lot)} — ${l.title}`);
         if (l.goal)
             io.out(`  objectif donné : ${l.goal} (à la place du titre dans les briefs)`);
-        io.out(`  budget du lot : ${l.budget} tokens comptés (base : ${lotBudgetBasis(lot.estimate, l.screen ? 'screen' : l.specLot ? 'spec' : undefined, l.escalationReserve ? env.config.escalation?.model : undefined)})`);
+        io.out(`  budget du lot : ${l.budget} tokens comptés (base : ${lotBudgetBasis(lot.estimate, budgetStage(lot, l.screen, env.config.maquette, l.repo, env.config.spec.dir), l.escalationReserve ? env.config.escalation?.model : undefined)})`);
         const mine = lots.filter((o) => o.repo === l.repo);
         const together = env.config.worktrees && (mine.length > 1 || multiSlot) && !mine.some((o) => o.repos?.length) && !!repoBranch(l.repo);
         io.out(together ? `  file ${basename(l.repo)} · en parallèle des autres lots du dépôt, dans son worktree (cadence/${id}/${lotSlug(l.project, l.lot)}, créé à la prise du créneau)` : `  file ${basename(l.repo)} · ${slot < 2 ? `créneau ${slot + 1}` : 'en attente d\'un créneau'}`);
@@ -459,7 +459,7 @@ function dryRun(lots, io, deps, { budget, id, multiSlot }) {
         }
         const steps = [{ kind: 'implement', model: l.model }];
         const specStage = !!(l.screen || l.specLot);
-        if (specStage && env.config.accept)
+        if (specStage && env.config.accept && !lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir))
             steps.unshift({ kind: 'accept', model: 'sonnet' });
         if (l.screen && env.config.maquette)
             steps.unshift({ kind: 'maquette', model: env.config.review.full });
@@ -513,12 +513,12 @@ function dryRun(lots, io, deps, { budget, id, multiSlot }) {
         const vars = { chemin: l.repo, lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', ux: '', choix: '', checks: '', news: l.visible ? newsText(l.lot) : '', captures: '', diff: 'git diff <sha de départ>..HEAD' };
         vars.decisions = decisionsText(humanDecisions(lot, lot.parent ? env.loadPlan().lots().find((x) => x.id === lot.parent) : undefined));
         if (specStage)
-            vars.spec = specText({ dir: env.config.spec.dir, render: env.config.spec.render, screen: l.screen, back: !!l.specLot });
+            vars.spec = specText({ dir: env.config.spec.dir, render: env.config.spec.render, screen: l.screen, light: lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir), back: !!l.specLot });
         if (l.screen && env.config.maquette)
-            vars.maquette = maquetteText({ fiche: `${env.config.spec.dir}/<écran>/fiche.yaml`, passes: 0, max: env.config.maquetteReviews });
+            vars.maquette = maquetteText({ fiche: `${env.config.spec.dir}/<écran>/fiche.yaml`, passes: 0, max: env.config.maquetteReviews, light: lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir) });
         if (l.specLot && env.config.fiche)
             vars.fiche = ficheReviewText({ fiche: `${env.config.spec.dir}/<sujet>/fiche.yaml`, passes: 0 });
-        if (specStage && env.config.accept) {
+        if (specStage && env.config.accept && !lightLot(l, lot, env.config.maquette, l.repo, env.config.spec.dir)) {
             const folder = `${env.config.spec.dir}/${l.screen ? '<écran>' : '<sujet>'}`;
             vars.accept = acceptText({ fiche: `${folder}/fiche.yaml`, maquette: `${folder}/maquette.html`, screen: !!l.screen, back: false, acceptation: acceptationFile(`${folder}/fiche.yaml`, l.lot), command: env.config.accept ?? '', test: env.config.test });
         }

package/dist/orchestrate/continue.js

@@ -9,7 +9,7 @@ import { RafError } from '../plan.js';
 import { lotBudget, projectEnv } from './command.js';
 import { readyFree } from '../ready-free.js';
 import { lotFinished, lotKey } from './state.js';
-import { specScreen } from './spec.js';
+import { budgetStage, stageScreen } from './spec.js';
 import { STOP_REQUESTED } from './cycle.js';
 /** `--until 18:00` : l'heure d'aujourd'hui (date de `now`) à partir de laquelle la vague ne tire plus de lot. */
 export function parseUntil(text, now) {
@@ -90,11 +90,13 @@ export function candidates(launch, o) {
         }
         let specDir = 'docs/specs';
         let escalating = false;
+        let maquette = true;
         let setting;
         try {
             const config = projectEnv(dir).config;
             specDir = config.spec.dir;
             escalating = !!config.escalation;
+            maquette = config.maquette;
             setting = config.continue;
         }
         catch {
@@ -108,7 +110,7 @@ export function candidates(launch, o) {
                 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)
+            if (lotBudget(lot.estimate, budgetStage(lot, stageScreen(dir, specDir, lot, maquette), maquette, dir, specDir), escalating) > o.remaining)
                 continue;
             out.push({ project, dir, lot });
         }

package/dist/orchestrate/cycle.js

@@ -36,7 +36,7 @@ import { lotIds, referenceIdsText } from '../ref/coverage.js';
 import { avalFicheText, ficheContracts, ficheRules, hasScreenPart } from './aval.js';
 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 { answeredText, checkSpec, costlyHypotheses, ficheHasBack, ficheReady, findFiche, hypothesisLines, answerAltersRule, hypothesisNote, lightLot, 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, expressSummary, lotKey, lotRepoPaths, neighbourDirs } from './state.js';
@@ -439,24 +439,19 @@ export function briefName(l, kind, integration = false) {
         return 'review-recheck'; // la revue d'intégration (R17) garde le gabarit qui porte {{integration}}
     return kind;
 }
-/** Gabarit de fiche livré avec le paquet, joint au brief de la spec (la session ne lit pas le dossier du paquet). */
-function ficheTemplate() {
+/** Fichier livré avec le paquet à côté des gabarits, joint à un brief (la session ne lit pas le dossier du paquet) ; undefined s'il manque. */
+function packageFile(name) {
     try {
-        return readFileSync(join(TEMPLATES_DIR, '..', 'fiche.yaml'), 'utf8');
+        return readFileSync(join(TEMPLATES_DIR, '..', name), 'utf8');
     }
     catch {
         return undefined;
     }
 }
+/** Gabarit de fiche livré avec le paquet, joint au brief de la spec. */
+const ficheTemplate = () => packageFile('fiche.yaml');
 /** Gabarit de la partie back de la fiche (L187), joint au brief de la spec d'un lot `spec: true`. */
-function ficheBackTemplate() {
-    try {
-        return readFileSync(join(TEMPLATES_DIR, '..', 'fiche-back.yaml'), 'utf8');
-    }
-    catch {
-        return undefined;
-    }
-}
+const ficheBackTemplate = () => packageFile('fiche-back.yaml');
 /** Le lot passe par l'étape spec : il déclare `screen:` (écran) ou `spec: true` (comportement sans écran, L188). */
 const hasSpecStage = (l) => !!(l.screen || l.specLot);
 /**
@@ -465,14 +460,7 @@ const hasSpecStage = (l) => !!(l.screen || l.specLot);
  */
 const partsOf = (c, fiche) => ({ screen: !!c.lot.screen, back: !!c.lot.specLot || (!!c.lot.screen && !!fiche && ficheHasBack(wd(c), fiche)) });
 /** Gabarit du lanceur de tests livré avec le paquet, joint au brief de l'étape accept. */
-function acceptRunner() {
-    try {
-        return readFileSync(join(TEMPLATES_DIR, '..', 'acceptation-runner.mjs'), 'utf8');
-    }
-    catch {
-        return undefined;
-    }
-}
+const acceptRunner = () => packageFile('acceptation-runner.mjs');
 /** Fiche du lot : celle de l'étape spec, ou la fiche retrouvée dans le dépôt (reprise). */
 function ficheOf(c) {
     const l = c.lot;
@@ -543,7 +531,7 @@ function briefFor(c, kind, local = false) {
         vars.spec = specText({
             dir: c.config.spec.dir,
             render: c.config.spec.render,
-            screen: l.screen,
+            screen: l.screen, light: lightLot(l, lot, c.config.maquette, wd(c), c.config.spec.dir),
             back,
             problems: l.specProblems,
             review: !reviewed.length ? undefined : back ? reviewedSheetText(reviewed, !!l.screen, session) : reviewedText(reviewed, session),
@@ -562,7 +550,7 @@ function briefFor(c, kind, local = false) {
         vars.reponse = '';
     }
     if (kind === 'maquette') {
-        vars.maquette = maquetteText({ fiche: ficheOf(c) ?? '', passes: l.maquette?.passes ?? 0, max: c.config.maquetteReviews, previous: l.maquetteConstats });
+        vars.maquette = maquetteText({ fiche: ficheOf(c) ?? '', passes: l.maquette?.passes ?? 0, max: c.config.maquetteReviews, previous: l.maquetteConstats, light: lightLot(l, lot, c.config.maquette, wd(c), c.config.spec.dir) });
         vars.reponse = '';
     }
     if (kind === 'accept') {
@@ -1300,18 +1288,21 @@ function summarize(rep, head, repoHeads) {
     const majeurs = Math.max(rep.majeurs, count('majeur'));
     return { conforme: bloquants === 0 && majeurs === 0, bloquants, majeurs, mineurs: Math.max(rep.mineurs, count('mineur')), verdict: rep.verdict.trim(), sousTaches: rep.sousTaches, nonVerifie: rep.nonVerifie, head, ...(repoHeads ? { repoHeads } : {}) };
 }
-function propose(c, text) {
+function propose(c, text, head) {
     if (!c.lot.proposals.includes(text))
         c.lot.proposals.push(text);
+    if (head)
+        (c.lot.proposalHeads ??= {})[text] ??= head;
 }
 const minorLine = (source, k) => `[mineur ${source}] ${k.fichier ? `${k.fichier}${k.ligne ? `:${k.ligne}` : ''} — ` : ''}${k.texte}`;
 const withoutLine = (line) => line.replace(/^(\[mineur \w+\] .*?):\d+ — /, '$1 — ');
-function addProposals(c, rep, source, withMinors = true) {
+function addProposals(c, rep, source, head, withMinors = true) {
     if (withMinors)
         for (const k of rep.constats.filter((k) => k.gravite === 'mineur'))
             propose(c, minorLine(source, k));
-    for (const t of rep.sousTaches)
-        propose(c, `[sous-tâche ${source}] ${t}`);
+    // La première revue qui émet la proposition en garde la date : une revue suivante qui la redit ne la rajeunit pas.
+    for (const t of rep.sousTaches.map((t) => `[sous-tâche ${source}] ${t}`))
+        propose(c, t, head);
 }
 function minorConstats(rep) {
     return rep.constats.filter((k) => k.gravite === 'mineur').map((k) => ({ source: 'code', gravite: k.gravite, fichier: k.fichier, ligne: k.ligne, texte: k.texte }));
@@ -1452,6 +1443,9 @@ function afterMaquette(c, fiche) {
     // Des constats de la revue de fiche attendent la revue de la maquette (lot mixte) : les deux partent ensemble à la seconde passe `spec`.
     if (l.ficheConstats?.length)
         return 'spec';
+    // Une maquette légère n'a pas de règles de comportement à verrouiller : pas d'accept, même si orchestrate.accept est déclaré.
+    if (lightLot(l, c.loadPlan().lot(l.lot), c.config.maquette, wd(c), c.config.spec.dir))
+        return 'implement';
     if (!c.config.accept) {
         if (!l.warnings.includes(NO_ACCEPT))
             l.warnings.push(NO_ACCEPT);
@@ -1782,7 +1776,7 @@ async function reviewSpecStep(c, r) {
     const summary = summarize(rep, done.after.head ?? '');
     const passes = (l[r.kind]?.passes ?? 0) + 1;
     // Fiche : les mineurs sont des notes du lot (design § 4). Maquette : inchangé (propositions du tableau final).
-    addProposals(c, rep, r.kind, r.kind !== 'fiche');
+    addProposals(c, rep, r.kind, summary.head, r.kind !== 'fiche');
     // Un lot rendu sur le refus d'écrire ses notes (R26) rejoue cette revue à la reprise : le compte des passes n'est posé qu'une fois les notes écrites.
     if (r.kind === 'fiche' && (await noteMinors(c, rep, `la ${r.label}`)))
         return;
@@ -2515,7 +2509,7 @@ async function reviewStep(c, kind) {
     const summary = summarize(rep, done.after.head ?? '', done.others.length ? Object.fromEntries(done.others.map((o) => [o.repo.rel, o.after.head ?? ''])) : undefined);
     if (kind === 'ux') {
         l.ux = summary;
-        addProposals(c, rep, 'ux');
+        addProposals(c, rep, 'ux', summary.head);
         l.uxVerdict = summary.verdict;
         l.constats = blockingConstats(rep, 'ux');
         save(c);
@@ -2569,7 +2563,7 @@ async function reviewStep(c, kind) {
         l.proposals = left;
         l.minorLines = [];
     }
-    addProposals(c, rep, 'code', !minorPass);
+    addProposals(c, rep, 'code', summary.head, !minorPass);
     if (summary.conforme)
         (l.reviewCounts ??= []).push(0); // une revue conforme compte pour 0 dans la comparaison de la convergence (L205)
     if (minorPass) {

package/dist/orchestrate/deja-traitee.js

@@ -0,0 +1,76 @@
+import { changedFiles, isAncestor, resolveCommit } from '../git.js';
+/** Début d'une proposition de sous-tâche d'une revue (`addProposals`) : les seules marquées, un mineur étant déjà une ligne de fichier précise. */
+const SUBTASK = '[sous-tâche ';
+/** Les fichiers que le texte d'une proposition cite (`src/a.ts`, `src/a.ts:42`, `` `docs/z.md` ``), dans l'ordre, sans doublon ; les adresses web et les nombres (`1.5`) n'en sont pas. */
+export function citedFiles(text) {
+    const out = [];
+    for (const raw of text.split(/[\s`'"“”«»(),;*[\]<>]+/)) {
+        const tok = raw.replace(/(:\d+(-\d+)?)+$/, '').replace(/[.:!?]+$/, '').replace(/^(\.\/)+/, '');
+        if (!tok || tok.includes('://') || !/^[\p{L}\p{N}_@.\-/]+\.[A-Za-z][A-Za-z0-9]+$/u.test(tok) || out.includes(tok))
+            continue;
+        out.push(tok);
+    }
+    return out;
+}
+/**
+ * La lecture de git : parmi `commits` (sha du lot, du plus ancien au plus récent), ceux qui ne sont pas dans l'histoire de la revue
+ * `head`, puis le premier qui modifie `file` (chemin entier ou fin de chemin). Un `head` que le dépôt ne connaît pas, ou une
+ * lecture impossible, ne marque rien : mieux vaut une proposition sans marque qu'une marque fausse.
+ */
+export function touchedByLotCommits(commits) {
+    // Une lecture par lot et par commit pour tout le rendu : le tableau pose la question pour chaque couple (proposition, fichier cité).
+    const lotShas = new Map();
+    const files = new Map();
+    const filesOf = (repo, c) => {
+        const key = `${repo}\0${c}`;
+        if (!files.has(key)) {
+            try {
+                files.set(key, changedFiles(repo, c));
+            }
+            catch {
+                files.set(key, null);
+            }
+        }
+        return files.get(key);
+    };
+    return (l, head, file) => {
+        if (!resolveCommit(l.repo, head))
+            return null;
+        if (!lotShas.has(l))
+            lotShas.set(l, commits(l));
+        for (const c of lotShas.get(l)) {
+            if (isAncestor(l.repo, c, head))
+                continue;
+            const changed = filesOf(l.repo, c);
+            if (!changed)
+                return null;
+            if (changed.some((f) => f === file || f.endsWith(`/${file}`)))
+                return c.slice(0, 7);
+        }
+        return null;
+    };
+}
+/**
+ * La ligne de proposition rendue au lead (L422) : une sous-tâche proposée dont un fichier cité a été modifié par un commit du lot
+ * postérieur à la revue qui l'a émise (`l.proposalHeads`) porte « — peut-être déjà traitée (<sha>) » ; les autres lignes sont inchangées.
+ * 28-10 : L230 ouvert sur des propositions déjà corrigées par la passe de correction, 5 passes perdues.
+ */
+export function proposalLine(l, proposal, touched) {
+    const head = l.proposalHeads?.[proposal];
+    if (!proposal.startsWith(SUBTASK) || !head)
+        return proposal;
+    for (const file of citedFiles(proposal)) {
+        let sha = null;
+        try {
+            sha = touched(l, head, file);
+        }
+        catch {
+            continue;
+        }
+        if (sha)
+            return `${proposal} — peut-être déjà traitée (${sha})`;
+    }
+    return proposal;
+}
+/** La lecture à employer : celle que l'appelant donne (tests), sinon git sur les commits du lot (`lotCommits` de l'appelant, sinon `fromGit` : ceux des étapes). */
+export const touchedReader = (deps, fromGit) => deps.touchedSince ?? touchedByLotCommits(deps.lotCommits ?? fromGit);

package/dist/orchestrate/integrate.js

@@ -6,6 +6,7 @@ import { sharedStateDir } from '../state.js';
 import { releaseLock, takeLock } from './lock.js';
 import { mergeUnreleased, moveToUnreleased, settleLotEntries, unreleasedSections } from './changelog-merge.js';
 import { mutexFor } from './mutex.js';
+import { readPlanConfig } from '../config.js';
 import { Plan } from '../plan.js';
 import { parseDocument } from 'yaml';
 import { git, gitFailure, tryGit } from './worktree.js';
@@ -91,11 +92,15 @@ function resolvePlan(work) {
         return false;
     const file = files[0];
     try {
+        // Les champs d'extension déclarés (L464) sont des propriétés des lots : sans les réglages, `bare` ne verrait pas un champ changé.
+        // Seuls les champs d'extension sont passés : le `plan.onWrite` du projet ne doit pas se lancer pendant un rebase.
+        const extras = readPlanConfig(join(work, 'cadence.yaml'), work)?.settings.extras;
+        const settings = extras ? { extras } : {};
         const stage = (n) => {
             const text = run(work, 'show', `:${n}:${file}`);
             writeFileSync(join(work, file), text);
             const head = parseDocument(text).toJSON();
-            return { lots: Plan.load(join(work, file)).lots(), head: JSON.stringify({ ...(head ?? {}), lots: undefined }) };
+            return { lots: Plan.load(join(work, file), settings).lots(), head: JSON.stringify({ ...(head ?? {}), lots: undefined }) };
         };
         const [b, o, t] = [stage(1), stage(2), stage(3)];
         const [base, ours, theirs] = [b.lots, o.lots, t.lots];
@@ -109,7 +114,7 @@ function resolvePlan(work) {
         if (added.some((t) => review(ours.find((o) => o.id === t.id)) !== review(base.find((b) => b.id === t.id))))
             return false;
         writeFileSync(join(work, file), run(work, 'show', `:2:${file}`));
-        const plan = Plan.load(join(work, file));
+        const plan = Plan.load(join(work, file), settings);
         for (const t of added)
             plan.recordReview(t.id, t.review.verdict, t.review.date, t.review.commit ?? null, t.review.repos, t.review.reporte);
         plan.save();

package/dist/orchestrate/lot-budget.js

@@ -38,7 +38,7 @@ function ordinaryBasis(estimate, stage) {
     const basis = estimate <= 0.5 ? "plancher d'un lot jusqu'à 0,5 j" : estimate <= 1 ? "p90 mesuré du total d'un lot de 0,5 à 1 j" : Math.round(estimate * LOT_BUDGET_PER_DAY) <= LOT_BUDGET_ONE_DAY ? `plancher de ${LOT_BUDGET_ONE_DAY} au-delà d'un jour, l'estimate × ${LOT_BUDGET_PER_DAY} ne le dépasse pas encore` : `${LOT_BUDGET_PER_DAY} par jour, p90 mesuré du total au-delà d'un jour`;
     if (!stage)
         return basis;
-    return `${ordinary} dérivés de l'estimate (${basis}), plus ${SPEC_STAGE_ALLOCATION} pour les étapes spec, ${stage === 'screen' ? 'maquette' : 'fiche'} et accept`;
+    return `${ordinary} dérivés de l'estimate (${basis}), plus ${SPEC_STAGE_ALLOCATION} pour ${stage === 'light' ? 'les étapes spec et maquette' : `les étapes spec, ${stage === 'screen' ? 'maquette' : 'fiche'} et accept`}`;
 }
 /** Budget d'un lot, dérivé de son estimate et de sa catégorie : empêche quelques lots d'avaler le budget de la vague au détriment des autres. Un lot à `screen:` vaut le total mesuré d'un lot à écran (L194) ; un lot à `spec: true` y ajoute l'allocation de son étape (L191) ; `escalation` (orchestrate.escalation déclarée) y ajoute la part de l'escalade (L349). */
 export const lotBudget = (estimate, stage, escalation = false) => lotBaseBudget(estimate, stage) + (escalation ? ESCALATION_RESERVE : 0);
@@ -46,5 +46,5 @@ const lotBaseBudget = (estimate, stage) => {
     const ordinary = estimate <= 0.5 ? LOT_BUDGET_FLOOR : Math.max(LOT_BUDGET_ONE_DAY, Math.round(estimate * LOT_BUDGET_PER_DAY));
     if (stage === 'screen')
         return Math.max(SCREEN_LOT_BUDGET, ordinary + SPEC_STAGE_ALLOCATION);
-    return ordinary + (stage === 'spec' ? SPEC_STAGE_ALLOCATION : 0);
+    return ordinary + (stage === 'spec' || stage === 'light' ? SPEC_STAGE_ALLOCATION : 0);
 };

package/dist/orchestrate/maquette.js

@@ -15,6 +15,9 @@ export function maquetteText(o) {
             ? `This is review ${rank} of ${o.max}${rank >= o.max ? ', the last review' : ''}: the spec writer fixed the points of the previous one (below). Check them first, then run the whole sweep again and report ALL the blocking and major findings of it in this report. Mark \`inchange: true\` on every blocking or major finding about a point the spec writer did not change and the previous review had not raised.`
             : `This is the first review of this mockup (${o.max} review${o.max > 1 ? 's' : ''} at most): there is no later review to keep a finding for. Report ALL the blocking and major findings in this first report; do not keep one back for a later review.`,
     ];
+    if (o.light) {
+        lines.push(`Light mockup (L459): the sheet covers only the states the lot touches. Sweep those states only, at ${LARGEURS.join(' and ')} px, and compare the target of each one to the capture of the current screen \`${folder}/actuel-<état>-<largeur>.png\` (a free file, not checked by the program; when one is missing the spec writer said so under "nonVerifie": judge the target against the code and the neighbouring pages). Report what makes the target worse than the current screen or inconsistent with the rest of the application, not the defects of the screen the lot does not touch.`);
+    }
     if (later && o.previous?.length)
         lines.push('', 'Points of the previous review that the spec writer had to fix:', ...bulletLines(o.previous));
     return lines.join('\n');

package/dist/orchestrate/spec.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { isMap, isNode, isScalar, isSeq, parse, parseDocument, stringify } from 'yaml';
 import { acceptationFile } from './accept.js';
 import { checkFiche, fichesDuDossier, LARGEURS } from '../spec.js';
+import { EXPRESS_MAX_ESTIMATE } from './express.js';
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 const list = (v) => (Array.isArray(v) ? v.filter(isObj) : []);
 /** Chemin (relatif au dépôt) de la fiche du lot sous `<dir>/<écran ou sujet>/fiche.yaml` (`ecran.lot` ou `sujet.lot`), ou null : sert à ne pas rejouer une spec déjà écrite. */
@@ -24,6 +25,34 @@ export function specScreen(repo, dir, lot) {
     const entered = fichesDuDossier(repo, dir).some(({ name, doc }) => isObj(doc.ecran) && (doc.ecran.lot === lot.id || existsSync(join(repo, dir, name, acceptation))));
     return entered ? lot.screen : undefined;
 }
+/**
+ * Maquette légère (L459) : un lot visible, sans `spec: true`, d'estimate au-dessus de la retouche (voie express), dont le `screen:` du plan n'est pas `page`
+ * (`component`, `journey` ou absent) passe par spec → maquette avant le code, sans accept. Se déduit du plan à chaque appel, sans champ d'état :
+ * `orchestrate.maquette: false` la retire (la maquette légère est la revue de maquette, sans elle rien n'est à valider).
+ */
+export function lightMaquette(lot, maquette) {
+    return maquette && !!lot.visible && !lot.spec && typeof lot.estimate === 'number' && lot.estimate > EXPRESS_MAX_ESTIMATE && lot.screen !== 'page';
+}
+/**
+ * Le lot a une acceptation scellée (`acceptation-<lot>.json` à côté d'une fiche à bloc `ecran` de `dir`) : il est entré dans la chaîne complète
+ * avant L459 (spec → maquette → accept) et la garde, même s'il répond aujourd'hui à `lightMaquette` ; une maquette légère n'écrit jamais d'acceptation.
+ */
+export function sealedAcceptation(repo, dir, lot) {
+    const acceptation = acceptationFile('fiche.yaml', lot);
+    return fichesDuDossier(repo, dir).some(({ name, doc }) => isObj(doc.ecran) && existsSync(join(repo, dir, name, acceptation)));
+}
+/** Le lot est une maquette légère : son état a une étape spec (`screen` posé au lancement), son lot du plan répond à `lightMaquette` et il n'a pas d'acceptation scellée (`sealedAcceptation`). Relu du plan et du dépôt à chaque appel, aucun champ d'état. */
+export const lightLot = (state, lot, maquette, repo, dir) => !!state.screen && lightMaquette(lot, maquette) && !sealedAcceptation(repo, dir, lot.id);
+/** `screen` de l'état d'un lot à étape spec : celui de `specScreen`, ou, pour une maquette légère, celui du plan (`component` quand le plan n'en déclare pas : l'état ne sert alors qu'à dire « ce lot a une étape spec »). */
+export function stageScreen(repo, dir, lot, maquette) {
+    return specScreen(repo, dir, lot) ?? (lightMaquette(lot, maquette) ? (lot.screen ?? 'component') : undefined);
+}
+/** Catégorie de budget d'un lot (`lotBudget`) : `screen` pour un écran page, `light` pour une maquette légère, `spec` pour un lot `spec: true` sans écran. */
+export function budgetStage(lot, stateScreen, maquette, repo, dir) {
+    if (stateScreen)
+        return lightLot({ screen: stateScreen }, lot, maquette, repo, dir) ? 'light' : 'screen';
+    return lot.spec ? 'spec' : undefined;
+}
 /** Texte sans accents ni majuscules, pour les mots-clés. */
 const plain = (s) => s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
 /**
@@ -267,20 +296,36 @@ export function hypothesisLines(doc) {
 }
 /** Texte de la note du lot pour une hypothèse (une note par règle). */
 export const hypothesisNote = (sujet, line) => `Hypothèses (fiche ${sujet}) — ${line}`;
+/** Consigne de rendu de la maquette : la commande que le projet déclare (`orchestrate.spec.render`), sinon Playwright. `use` : comment la reprendre. */
+const renderLine = (render, use) => render
+    ? `The project declares how to render mockups (\`orchestrate.spec.render\`): \`${render}\` (from the repository root). ${use}; fall back on Playwright only if it cannot run, and say so under "nonVerifie".`
+    : 'No render command is declared (`orchestrate.spec.render`): render with Playwright (open `maquette.html` as a local file, resize to each width, open each `#etat-<état>`).';
+/** Consigne de la maquette d'un lot `screen: page` (ou déjà entré dans la chaîne complète). */
+const pageLines = (o) => [
+    `The lot declares \`screen: ${o.screen}\`. The specs of this project live in \`${o.dir}/<écran>/\` (one folder per screen, \`<écran>\` = the kebab-case \`ecran.id\` of the sheet).`,
+    `Render each state of the mockup at ${LARGEURS.map((w) => `${w}`).join(' and ')} px width: one capture per state and per width, named \`maquette-<état>-<largeur>.png\` (e.g. \`maquette-vide-1440.png\`).`,
+    renderLine(o.render, 'Use it'),
+];
+/** Consigne de la maquette légère (L459) : l'écran actuel et la version visée des seuls états touchés. */
+const lightLines = (o) => [
+    `This lot is a visible lot that is not a whole page: write a light mockup, before any code. The specs of this project live in \`${o.dir}/<écran>/\` (one folder per screen, \`<écran>\` = the kebab-case \`ecran.id\` of the sheet).`,
+    'Cover only the states the lot touches (not the whole screen). For each touched state, capture the CURRENT screen of the application at each width, then the target version: the sheet and the mockup are limited to the states, fields and rules the lot changes.',
+    `Name the captures of the current screen \`actuel-<état>-<largeur>.png\` and those of the target \`maquette-<état>-<largeur>.png\`, one per touched state and per width (${LARGEURS.join(' and ')} px; e.g. \`actuel-vide-1440.png\`, \`maquette-vide-1440.png\`), in the folder of the sheet. The program checks the captures of the target, not the \`actuel-*\` ones.`,
+    'If the current screen cannot be captured (the application does not start, the page is protected), say so under "nonVerifie" and base the mockup on the code: never invent a capture of the current screen.',
+    'Each touched state is a section `id="etat-<état>"` of `maquette.html`, and each touched field carries a `data-testid`.',
+    renderLine(o.render, 'Use it for the target'),
+];
 /** Consigne propre à l'étape spec dans le brief : dossier, largeurs, commande de rendu, et les écarts de la passe précédente. */
 export function specText(o) {
     const lines = [];
-    if (o.screen) {
-        lines.push(`The lot declares \`screen: ${o.screen}\`. The specs of this project live in \`${o.dir}/<écran>/\` (one folder per screen, \`<écran>\` = the kebab-case \`ecran.id\` of the sheet).`, `Render each state of the mockup at ${LARGEURS.map((w) => `${w}`).join(' and ')} px width: one capture per state and per width, named \`maquette-<état>-<largeur>.png\` (e.g. \`maquette-vide-1440.png\`).`, o.render
-            ? `The project declares how to render mockups (\`orchestrate.spec.render\`): \`${o.render}\` (from the repository root). Use it; fall back on Playwright only if it cannot run, and say so under "nonVerifie".`
-            : 'No render command is declared (`orchestrate.spec.render`): render with Playwright (open `maquette.html` as a local file, resize to each width, open each `#etat-<état>`).');
-    }
+    if (o.screen)
+        lines.push(...(o.light ? lightLines(o) : pageLines(o)));
     if (o.back) {
         lines.push(o.screen
             ? `The sheet has both parts, \`sujet\`, \`cas\`, \`contrats\`, \`donnees\` next to \`ecran\`, in the same folder (\`sujet.id\` = \`ecran.id\` = the folder name, \`sujet.lot\` = \`ecran.lot\`); the API calls of the screen are listed once in \`contrats\`, and the actions point to them with \`contrat: Ax\`.`
             : `The lot declares \`spec: true\` (it changes a behaviour, with no screen). The specs of this project live in \`${o.dir}/<sujet>/\` (one folder per subject, \`<sujet>\` = the kebab-case \`sujet.id\` of the sheet); the sheet has no screen part.`);
     }
-    if (o.screen && !o.back) {
+    if (o.screen && !o.back && !o.light) {
         lines.push(`If the lot also changes a behaviour (an API call, a stored datum, a contract), add the back part to the same sheet: \`sujet\`, \`cas\`, \`contrats\`, \`donnees\` next to \`ecran\` (\`sujet.id\` = \`ecran.id\` = the folder name, \`sujet.lot\` = \`ecran.lot\`); the program then also has the sheet reviewed (rules sourced, contradictions, errors and limits, one test per rule), before the mockup. A lot that only draws a screen keeps a sheet without \`sujet\`.`);
     }
     if (o.template)