@sylad/cadence 1.40.0 → 1.42.1

package/dist/orchestrate/attente.js

@@ -0,0 +1,82 @@
+import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { processStart } from '../proc.js';
+import { holderAlive } from './lock.js';
+import { lotKey } from './state.js';
+import { priorityRank, readPriority } from './continue.js';
+const waitersDir = (home) => join(home, 'waiters');
+let waiterSeq = 0;
+/** Les attentes vivantes, toutes vagues confondues, de la première servie à la dernière : étape en cours avant nouveau tirage, puis rang de priorité, puis ancienneté. */
+function liveWaiters(home) {
+    let names;
+    try {
+        names = readdirSync(waitersDir(home)).filter((n) => n.endsWith('.json'));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const n of names) {
+        const file = join(waitersDir(home), n);
+        try {
+            const r = JSON.parse(readFileSync(file, 'utf8'));
+            const w = {
+                pid: Number(r.pid),
+                start: r.start === undefined ? undefined : String(r.start),
+                wave: String(r.wave),
+                since: Number(r.since),
+                seq: Number(r.seq),
+                fresh: !!r.fresh,
+                rank: Number.isFinite(Number(r.rank)) ? Number(r.rank) : Number.MAX_SAFE_INTEGER,
+                file,
+            };
+            if (holderAlive(w.pid, w.start))
+                out.push(w);
+            else
+                rmSync(file, { force: true }); // le processus est mort sans désinscrire son attente
+        }
+        catch {
+            // inscription illisible (en cours d'écriture) : ignorée à ce tour
+        }
+    }
+    return out.sort((a, b) => Number(a.fresh) - Number(b.fresh) || a.rank - b.rank || a.since - b.since || a.pid - b.pid || a.seq - b.seq);
+}
+/** Inscrit une attente de créneau le temps de `run`, qui reçoit la question « est-ce mon tour ? » ; désinscrite à la fin, obtenue ou abandonnée (L531). */
+export async function whileWaiting(home, o, run) {
+    const me = {
+        pid: process.pid,
+        start: processStart(process.pid) ?? undefined,
+        wave: o.wave,
+        since: Date.now(),
+        seq: waiterSeq++,
+        fresh: o.fresh ?? false,
+        rank: o.rank ?? Number.MAX_SAFE_INTEGER,
+    };
+    const file = join(waitersDir(home), `${me.pid}-${me.seq}.json`);
+    mkdirSync(waitersDir(home), { recursive: true });
+    writeFileSync(file, JSON.stringify(me));
+    try {
+        return await run(() => liveWaiters(home)[0]?.file === file);
+    }
+    finally {
+        rmSync(file, { force: true });
+    }
+}
+/** Un créneau est à prendre quand le total est sous le plafond et qu'aucune attente vivante ne passe avant la nôtre. */
+export const hasRoom = (taken, limit, myTurn) => taken() < limit && myTurn();
+/**
+ * La place dans la file des créneaux de la session que le lot `key` (`projet:lot`) lance : un lot qui n'a qu'un pas (celui qui part, déjà inscrit) n'a rien joué (`fresh`) ;
+ * le rang est celui de son projet dans `priority:` (`--priority`, sinon le cadence.yaml du dossier de lancement ; illisible : rang neutre). Lot inconnu : place neutre.
+ */
+export function slotPlace(all, launch, given, key) {
+    const l = key ? all.find((x) => lotKey(x.project, x.lot) === key) : undefined;
+    if (!l)
+        return {};
+    const fresh = l.steps.length <= 1;
+    try {
+        return { fresh, rank: priorityRank(l.project, given ?? readPriority(launch)) };
+    }
+    catch {
+        return { fresh }; // priority: illisible : rang neutre (après tous les déclarés), le lancement n'en dépend pas
+    }
+}

package/dist/orchestrate/command.js

@@ -1,7 +1,7 @@
 import { gateProgress, gateText } from '../audit.js';
 import { execFileSync } from 'node:child_process';
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { availableParallelism, homedir, tmpdir } from 'node:os';
+import { availableParallelism, tmpdir } from 'node:os';
 import { testWorkersFrom } from './workers.js';
 import { basename, join, resolve } from 'node:path';
 import { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readOrchestrateConfig, readPlanConfig } from '../config.js';
@@ -24,20 +24,22 @@ 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';
 import { installPrePush, keepGateGuard, longDuration, removePrePush } from './guard.js';
-import { buildArgs, buildLocalArgs, killSessions, MODEL_ALIASES, mcpServersFor, readAgents, realClaude, enabledPlugins, settingsFiles } from './launch.js';
+import { buildArgs, buildLocalArgs, claudeConfigDir, 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 { slotPlace } from './attente.js';
 import { AddFeed, addNotAlone, addToLive, openInRepo, projectName } from './ajout.js';
 import { repoRefusals, trackedDirty } from './depot.js';
+import { adoptLeadReview, depositIntegrations, depositsOnly, integrationText, runsElsewhere, takeIntegrations } from './integration-vivante.js';
 import { removeWorktree } from './retrait.js';
 import { repoBranch } from './integrate.js';
 import { baseBranchOf, keptLines, lotBranch, lotTreeDir, planFileSet, recoverTree } from './worktree.js';
-import { agentOf, schemaFor } from './schemas.js';
+import { effortKey, schemaFor, stepAgent } from './schemas.js';
 import { resolveLotRepos } from '../repos.js';
 import { excludeState, lotFinished, lotKey, lotRepoPaths, lotSlug, neighbourDirs, newLot, RunStore } from './state.js';
 import { isExpress } from './express.js';
@@ -320,7 +322,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 +331,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 +444,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 +461,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 +515,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 });
         }
@@ -527,7 +529,7 @@ function dryRun(lots, io, deps, { budget, id, multiSlot }) {
             writeFileSync(file, renderBrief(briefName(l, s.kind), s.kind === 'fiche' || vars.fiche === undefined ? vars : { ...vars, fiche: '' }, deps.templatesDir)); // la consigne de revue de fiche ne sert qu'au brief de la fiche : implement et review en sont la base d'une délégation à la main
             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: agentOf(s.kind), 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));
+            const args = (local ? buildLocalArgs : buildArgs)({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model === 'local' ? 'sonnet' : s.model, local, effort: env.config.effort[effortKey(s.kind)], schema: schemaFor(s.kind), agent: stepAgent(s.kind), 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));
@@ -1102,9 +1104,8 @@ async function execute(wave, lots, store, io, deps, today, args, all = lots) {
         throw e;
     }
     // Plafond de sessions simultanées, toutes vagues confondues : chaque session attend un créneau libre avant de partir.
-    const claude = async (args, o) => {
-        const free = await acquireSlot(home, cap, {
-            wave: wave.id,
+    const claude = async (argv, o) => {
+        const free = await acquireSlot(home, cap, { wave: wave.id, ...slotPlace(all, launch, args.priority, o.lot), // L531 : place dans la file des créneaux, commune aux vagues
             pollMs: deps.slotPollMs,
             // L332 : une demande écrite pendant l'attente (`--drop` de ce lot, `--stop-after-current`) l'interrompt ; la session ne part pas.
             abandon: () => {
@@ -1120,7 +1121,7 @@ async function execute(wave, lots, store, io, deps, today, args, all = lots) {
             onGot: (ms) => wctx.log(`${o.lot ? `${o.lot} · ` : ''}créneau de session obtenu après ${duration(ms)} d'attente`),
         });
         try {
-            return await deps.claude(args, o);
+            return await deps.claude(argv, o);
         }
         finally {
             free();
@@ -1259,6 +1260,8 @@ async function execute(wave, lots, store, io, deps, today, args, all = lots) {
                         taken.push(c);
                     }
                 }
+                // L532 : les intégrations déposées par `--resume --integrate` pendant la vague sont reprises de la même façon, au tour où le lot peut jouer.
+                taken.push(...(await takeIntegrations({ store, ctxs, wctx, settled }, canRun)));
                 if (taken.length) {
                     try {
                         updateWaveRepos(home, process.pid, repos.filter((x) => !freed.has(x)), lanes());
@@ -1469,6 +1472,9 @@ async function resume(args, argv, io, deps, launch, today) {
     const store = typeof args.resume === 'string' ? RunStore.find(launch, args.resume) : singleUnfinished(launch);
     if (!store)
         throw new RafError(`vague inconnue : ${args.resume}`);
+    // L532 : `--integrate` seul sur une vague qui tourne encore dépose l'intégration dans sa file au lieu de refuser ; dit avant l'instantané (le dépôt ne demande rien à son code) ; une reprise qui attend le dépôt (L443) est inscrite vivante mais ne joue pas encore : la vague doit être « running ». Avec une autre option de reprise ou --replay, le refus ci-dessous reste.
+    if (depositsOnly(args, runsElsewhere(store, launch)))
+        return depositIntegrations(args.integrate, io, store);
     if (deps.snapshot) {
         // La reprise tourne sur l'instantané de la vague, jamais sur le dist/ courant ; une vague d'avant L61 n'en a pas.
         if (LOT_LIKE.test(store.id) && snapshotExists(store.dir)) {
@@ -1743,19 +1749,14 @@ async function resume(args, argv, io, deps, launch, today) {
         for (const l of integ) {
             const k = lotKey(l.project, l.lot);
             const lead = leadReviewed.get(l);
-            if (lead) {
-                // La revue du lead tient lieu de revue du lot : le rebase reporte son verdict (même patch-id) ou joue la revue courte du diff rebasé.
-                l.next = 'integrate';
-                l.code = { conforme: true, bloquants: 0, majeurs: 0, mineurs: 0, verdict: lead.verdict, sousTaches: [], nonVerifie: [], head: lead.head };
-                l.verdict = lead.verdict;
-                l.constats = [];
-            }
+            if (lead)
+                adoptLeadReview(l, lead);
             const planNote = l.next !== 'integrate'; // rendu sur une écriture de plan refusée (--replay) : le lot repart de l'étape gardée
             if (planNote && l.outcome?.startsWith(HYPOTHESES_HANDBACK))
                 l.hypotheses = undefined; // les notes d'hypothèses se posent de nouveau (sans doublon) à l'entrée de l'étape
             l.status = 'suspended';
             l.outcome = null;
-            const text = lead ? `intégration reprise (--resume --integrate) : revue conforme du lead hors vague, ${lead.head.slice(0, 7)}` : planNote ? `écriture du plan reprise à l'étape ${l.next} (--resume --replay)` : 'intégration reprise (--resume --integrate)';
+            const text = planNote ? `écriture du plan reprise à l'étape ${l.next} (--resume --replay)` : integrationText(lead ?? null);
             store.journal(`${k} → suspended — ${text}`);
             io.out(`${k} → suspended — ${text}`);
         }
@@ -1847,6 +1848,6 @@ export function realOrchestrateDeps(env) {
         },
         agentsDir: AGENTS_DIR,
         snapshot: child ? undefined : { packageRoot: PACKAGE_ROOT, reexec: spawnReexec },
-        claudeHome: env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'),
+        claudeHome: claudeConfigDir(env),
     };
 }

package/dist/orchestrate/continue.js

@@ -1,15 +1,14 @@
-import { existsSync, readFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
-import { parse } from 'yaml';
 import { nextUp } from '../audit.js';
 import { planLoader } from '../config.js';
 import { gitRoot } from '../git.js';
 import { findProjects, isProject } from '../lead.js';
 import { RafError } from '../plan.js';
+import { readYamlKey } from '../yaml-keys.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) {
@@ -32,16 +31,7 @@ export function parsePriority(text) {
 /** Clé `priority:` du cadence.yaml du dossier de lancement (le dossier parent des projets) ; absente : aucune priorité déclarée. */
 export function readPriority(launchDir) {
     const file = join(launchDir, 'cadence.yaml');
-    if (!existsSync(file))
-        return [];
-    let raw;
-    try {
-        raw = parse(readFileSync(file, 'utf8'));
-    }
-    catch (e) {
-        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
-    }
-    const p = raw?.priority;
+    const p = readYamlKey(file, 'priority');
     if (p == null)
         return [];
     if (!Array.isArray(p) || p.length === 0 || p.some((n) => typeof n !== 'string' || !n.trim()))
@@ -90,11 +80,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 +100,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

@@ -8,7 +8,7 @@ import { tmpdir } from 'node:os';
 import { coveredTasks, lotCommits, lotWork } from '../audit.js';
 import { planLoader, readDocsConfig, readPlanConfig } from '../config.js';
 import { PLAN_ACTIONS, leadAnswerMessage, planCommitMessage } from '../plan-commit.js';
-import { articleRepoDir, articlesBrief, docSyncBrief, docSyncGaps, filesOf, gapMessage } from '../docsync.js';
+import { articleRepoDir, articlesBrief, docSyncBrief, filesOf, gapMessage, lotDocSyncGaps } from '../docsync.js';
 import { testGateMissing } from '../testgate.js';
 import { citesPriorWork, keepPrecheckReading, localYesNote, precheckNothingToFind } from './precheck.js';
 import { PROBE_FAILED, PROBE_RESERVE, probeStep, probeVars, scheduleProbe } from './probe.js';
@@ -30,13 +30,13 @@ import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, t
 import { cleanPlaywrightOutput, pushed, remoteAdvances, snapshot } from './guard.js';
 import { sumTokens } from './result.js';
 import { cutReport, EXTENSION_MS, MAX_EXTENSIONS, workTimeoutMs } from './timeouts.js';
-import { ACCEPT_SCHEMA, agentOf, checkShape, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, SPEC_SCHEMA, WORK_SCHEMA } from './schemas.js';
+import { ACCEPT_SCHEMA, checkShape, effortKey, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, SPEC_SCHEMA, stepAgent, WORK_SCHEMA } from './schemas.js';
 import { acceptationFile, acceptCommands, isAcceptList, acceptText, checkAcceptation, findAcceptation, isAcceptationFile, lockViolations, lotStartHead, parseAcceptation, planAcceptRuns, redSha, resealedRouge, sealAcceptation, setVert } from './accept.js';
 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';
@@ -413,7 +413,7 @@ function docGaps(c) {
     const { sync } = docsConfig(c);
     const plan = histPlan(c);
     const acknowledged = !!plan.lots().find((x) => x.id === c.lot.lot)?.docsOk;
-    return { sync, gaps: sync.length && !acknowledged ? docSyncGaps(sync, filesOf(wd(c), lotWork(plan, wd(c), c.lot.lot))) : [] };
+    return { sync, gaps: sync.length && !acknowledged ? lotDocSyncGaps(sync, wd(c), lotWork(plan, wd(c), c.lot.lot)) : [] };
 }
 /** Cause du renvoi au lead d'un lot dont l'écart docs.sync est ouvert (L317), null sans écart. */
 function openDocGap(c) {
@@ -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') {
@@ -711,7 +699,7 @@ async function session(c, kind, local = false) {
     if (WRITE_STEPS.includes(kind) && (lotOver(l) || (kind === 'fix' && !fixAffordable(l))))
         return overBudget(c, kind === 'fix' && !lotOver(l));
     const model = ['spec', 'accept', 'fiche', 'probe'].includes(kind) ? 'sonnet' : write ? (kind === 'fix' && l.escalation?.stage === 'fix' ? l.escalation.model : l.model) : local ? 'local' : kind === 'precheck' ? 'sonnet' : reviewModel(c, kind); // le contrôle préalable ne fait que lire : pas d'Opus
-    const effort = c.config.effort[kind === 'review-small' ? 'review' : kind];
+    const effort = c.config.effort[effortKey(kind)];
     const before = await snapshot(wd(c));
     const neighbours = l.repos ?? [];
     const beforeOthers = await Promise.all(neighbours.map((r) => snapshot(r.path)));
@@ -771,7 +759,7 @@ async function session(c, kind, local = false) {
         effort,
         local,
         schema: schemaFor(kind),
-        agent: kind === 'fix' && l.docsFix ? 'doc-keeper' : agentOf(kind),
+        agent: stepAgent(kind, l.docsFix),
         cwd: wd(c),
         wave: w.id,
         lot: lotKey(l.project, l.lot),
@@ -1455,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);

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/integration-vivante.js

@@ -0,0 +1,138 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { planLoader } from '../config.js';
+import { leadReviewedHandBack } from './cycle.js';
+import { trackedDirty } from './depot.js';
+import { cadenceHome, liveWaves } from './registry.js';
+import { waveReadsIntegrateQueue } from './snapshot.js';
+import { lotKey } from './state.js';
+import { resumeCommand } from './table.js';
+import { lotTreeDir } from './worktree.js';
+/**
+ * Un lot rendu que `--integrate` peut reprendre (L279, L370) : rendu à l'étape d'intégration (`next: integrate`), ou rendu ailleurs puis corrigé et revu conforme par le lead dans son worktree (la revue porte le dernier commit).
+ * Rend le verdict du lead dans ce second cas (`lead`), `{ lead: null }` dans le premier, null si le lot n'est pas reprenable.
+ */
+export function integrationHandBack(store, l) {
+    if (l.status !== 'handed-back')
+        return null;
+    if (l.next === 'integrate')
+        return { lead: null };
+    // La revue du lead est écrite par `raf review` lancé dans le worktree : c'est le plan du worktree qui la porte, pas celui du dépôt principal.
+    const tree = lotTreeDir(store.dir, l.project, l.lot, l.repo);
+    const lead = existsSync(join(tree, '.git')) ? leadReviewedHandBack(l, planLoader(tree)(), tree) : null;
+    return lead ? { lead } : null;
+}
+/** La revue du lead tient lieu de revue du lot : le rebase reporte son verdict (même patch-id) ou joue la revue courte du diff rebasé. */
+export function adoptLeadReview(l, lead) {
+    l.next = 'integrate';
+    l.code = { conforme: true, bloquants: 0, majeurs: 0, mineurs: 0, verdict: lead.verdict, sousTaches: [], nonVerifie: [], head: lead.head };
+    l.verdict = lead.verdict;
+    l.constats = [];
+}
+/** La ligne de journal d'une intégration reprise (à la reprise comme sur la vague vivante). */
+export const integrationText = (lead) => (lead ? `intégration reprise (--resume --integrate) : revue conforme du lead hors vague, ${lead.head.slice(0, 7)}` : 'intégration reprise (--resume --integrate)');
+/** Le contrôle d'une cible de `--integrate` : sa clé `projet:lot`, ou le refus. */
+function checkTarget(store, t, seen) {
+    const matches = store.lots().filter((l) => l.lot === t.lot && (t.project ? l.project === t.project : true));
+    const where = `${t.project ? `${t.project}:` : ''}${t.lot}`;
+    if (matches.length !== 1)
+        return { refusal: matches.length ? `--integrate ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--integrate ${where} : lot inconnu dans la vague ${store.id}` };
+    const l = matches[0];
+    const key = lotKey(l.project, l.lot);
+    if (seen.includes(key))
+        return { refusal: `--integrate ${key} : lot visé deux fois` };
+    if (!integrationHandBack(store, l))
+        return { refusal: `--integrate ${key} : le lot n'est pas rendu à l'étape d'intégration (${l.status}, étape ${l.next ?? 'aucune'} : ${l.outcome ?? 'sans cause'})` };
+    return { key };
+}
+/**
+ * `--resume --integrate` sur une vague VIVANTE (L532) : l'intégration est déposée dans la file de la vague (`integrates.log`), qui la reprend entre deux étapes, comme un `--add`.
+ * Sans cela le lead attendait la fin de la vague (qui dure des heures sous `--continue`). Les lots visés sont contrôlés comme à la reprise : connus, rendus à l'intégration ou revus par le lead.
+ */
+export function depositIntegrations(targets, io, store) {
+    const refusals = [];
+    const keys = [];
+    for (const t of targets) {
+        const r = checkTarget(store, t, keys);
+        if ('key' in r)
+            keys.push(r.key);
+        else
+            refusals.push(r.refusal);
+    }
+    if (!waveReadsIntegrateQueue(store.dir))
+        refusals.push(`la vague ${store.id} ne lit pas la file d'intégrations (lancée avec une version de cadence d'avant L532) : attendre sa fin, puis ${resumeCommand(store.id, '--integrate', '<projet>:<lot>')}`);
+    if (refusals.length) {
+        for (const r of refusals)
+            io.err(`orchestrate : ${r}`);
+        return 2;
+    }
+    for (const key of keys) {
+        const id = store.requestIntegrate(key);
+        // La vague a pu finir entre le contrôle et le dépôt : sa file ne sera plus lue, la demande est retirée et le lead reprend à la main.
+        if (!liveWaves(cadenceHome()).some((w) => w.wave === store.id)) {
+            store.markIntegrateTaken(id);
+            io.err(`orchestrate : ${key} : la vague ${store.id} vient de finir, intégration non prise : ${resumeCommand(store.id, '--integrate', key)}`);
+            return 2;
+        }
+        store.journal(`demande : intégration du lot ${key}`);
+        io.out(`${key} : intégration déposée — la vague ${store.id} la reprend entre deux étapes dès qu'un créneau est libre`);
+    }
+    return 0;
+}
+/** Pourquoi la demande ne peut plus être jouée (lot inconnu, déjà repris, revue du lead perdue), ou le lot et ce qui le reprend. */
+function eligible(store, ctxs, lot) {
+    const c = ctxs.find((x) => lotKey(x.lot.project, x.lot.lot) === lot);
+    if (!c)
+        return { why: 'lot inconnu' };
+    if (c.lot.status !== 'handed-back')
+        return { why: `le lot n'est plus rendu (${c.lot.status})` };
+    const back = integrationHandBack(store, c.lot);
+    return back ? { c, back } : { why: "le lot n'est pas rendu à l'étape d'intégration ni revu par le lead au dernier commit de son worktree" };
+}
+/**
+ * La vague vivante prend les intégrations déposées (L532) : le lot rendu repart à l'étape `integrate` comme sous `--resume --integrate`, quand `canRun` l'accepte ; une demande dont le lot ne qualifie plus
+ * (déjà repris, commit après la revue du lead, fichier suivi modifié) est écartée et dite au journal. Rend les lots à jouer ; `settled` est la liste des lots qui ont fini de jouer.
+ */
+export async function takeIntegrations(w, canRun) {
+    const { store, wctx } = w;
+    const taken = [];
+    const drop = (id, lot, why) => {
+        wctx.log(`${lot} : intégration écartée (${why})`);
+        store.markIntegrateTaken(id);
+    };
+    for (const e of store.integrateQueue()) {
+        const r = eligible(store, w.ctxs, e.lot);
+        if ('why' in r) {
+            drop(e.id, e.lot, r.why);
+            continue;
+        }
+        const { c, back } = r;
+        if (!canRun(c))
+            continue;
+        const dirty = await trackedDirty(lotTreeDir(store.dir, c.lot.project, c.lot.lot, c.lot.repo));
+        if (dirty.length) {
+            drop(e.id, e.lot, `arbre sale, ${dirty.length} fichier(s) suivi(s) modifié(s) : ${dirty.join(', ')}`);
+            continue;
+        }
+        if (back.lead)
+            adoptLeadReview(c.lot, back.lead);
+        c.lot.next = 'integrate';
+        c.lot.status = 'suspended';
+        c.lot.outcome = null;
+        store.writeLot(c.lot);
+        store.markIntegrateTaken(e.id);
+        wctx.log(`${e.lot} → suspended — ${integrationText(back.lead)}`);
+        // Le lot avait fini de jouer (`settled`) : il rejoue, il tient de nouveau un créneau (L433).
+        w.settled.delete(c);
+        taken.push(c);
+    }
+    return taken;
+}
+/** `--resume --integrate` seul (sans --replay, --answer, --budget, --drop ni --continue) sur une vague qui tourne encore : l'intégration est déposée, pas refusée. */
+export function depositsOnly(a, live) {
+    return live && a.integrate.length > 0 && a.integrate.every((t) => !t.replay) && !a.answers.length && !a.lotBudgets.length && !a.drop.length && a.budget === undefined && !a.continue;
+}
+/** La vague tourne dans un autre processus de ce dossier, et joue (« running ») : une reprise qui attend le dépôt (L443) est inscrite vivante sans rien jouer encore, elle ne lit pas la file. */
+export function runsElsewhere(store, launch) {
+    return store.readWave()?.status === 'running' && liveWaves(cadenceHome()).some((w) => w.wave === store.id && w.cwd === launch && w.pid !== process.pid);
+}