@sylad/cadence 1.37.0 → 1.38.1

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "cadence",
       "description": "Session start and close rituals driven by a versioned plan (raf), and deliveries proven by their effect. Needs the cadence CLI (npm i -g @sylad/cadence).",
-      "version": "1.37.0",
+      "version": "1.38.1",
       "source": "./",
       "author": {
         "name": "Sylvain Ladoire"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cadence",
   "description": "A repo-native working method: session start and close rituals driven by a versioned plan (raf), deliveries proven by their effect, and three reviewer agents (UX, code, QA).",
-  "version": "1.37.0",
+  "version": "1.38.1",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/README.md

@@ -47,8 +47,8 @@ Details: [docs/skills.md](docs/skills.md) and [docs/cadence-hud.md](docs/cadence
 
 ## Where to read more
 
-- [docs/raf.md](docs/raf.md): the plan, its commands and its file.
-- [docs/orchestrate.md](docs/orchestrate.md): waves, budgets, and [the edge-case probe](docs/orchestrate.md#the-edge-case-probe-orchestrateprobe-l497).
+- [docs/raf.md](docs/raf.md): the plan, its commands, its file, and [a lot of the lead](docs/raf.md#a-lot-of-the-lead-local-l519).
+- [Waves](docs/orchestrate.md): [probe](docs/orchestrate.md#the-edge-case-probe-orchestrateprobe-l497), [express](docs/orchestrate.md#express-lane-l519).
 - [Brief grid and pre-check reading](docs/mesures/brief-implementation-enrichi-avant-apres.md): grid of the code-reviewer in the `implement` brief (L523).
 - [docs/deliver.md](docs/deliver.md): wait for the CI, deploy, verify the effect; [docs/remote-gate.md](docs/remote-gate.md): the gate on another machine.
 - [docs/spec.md](docs/spec.md): screen and back-end sheets.

package/bin/cadence.js

@@ -12,7 +12,7 @@ const io = {
 
 if (tool === 'raf') {
   process.exitCode = await run(args, io);
-} else if (['news', 'session', 'deliver', 'verify', 'skills', 'orchestrate', 'lead', 'corrections', 'perf', 'spec', 'ref', 'config', 'release'].includes(tool)) {
+} else if (['news', 'session', 'deliver', 'verify', 'skills', 'orchestrate', 'lead', 'corrections', 'perf', 'spec', 'ref', 'config', 'release', 'local'].includes(tool)) {
   process.exitCode = await run([tool, ...args], io);
 } else if (tool === '--version' || tool === '-v') {
   process.exitCode = await run([tool], io);
@@ -37,6 +37,9 @@ if (tool === 'raf') {
   cadence ref measure <slug> <page> <page | x,y | x,y,l,h> [--quoi couleurs|contraste|boites|texte] [--largeur 1440] [--json]
                     mesure une zone d'une page rendue : couleurs, contraste WCAG 2.2, boîtes, mots OCR et taille de police estimée,
                     ramenés à 1440 px de large, tolérance déclarée
+  cadence local start|done <lot>
+                    tâche locale du lead sur un lot posé par raf add --local : start verrouille le dépôt comme une vague,
+                    done joue la porte une fois et libère le dépôt si elle est verte
   cadence release patch|minor|major [--dry-run]
                     prépare le commit de version (fichiers de version, CHANGELOG) sans rien commiter ni publier ;
                     imprime les étapes du lead dans l'ordre et vérifie docs/whats-new.md

package/dist/cli.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { basename, dirname, join, posix, relative, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
@@ -24,36 +24,36 @@ import { schedule } from './schedule.js';
 import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.js';
 import { configSet } from './config-set.js';
 import { movePriority } from './priority.js';
-import { findProjects, readDepth, leadTour, TITLE_MAX, truncate, readLeadUx, tourFreeLine, readLeadContextThreshold, findLeadDir, tourLine, tourNoTestLines, tourWorktreeLines } from './lead.js';
+import { findProjects, isProject, readDepth, leadTour, TITLE_MAX, truncate, readLeadUx, tourFreeLine, readLeadContextThreshold, findLeadDir, tourLine, tourNoTestLines, tourWorktreeLines } from './lead.js';
 import { configuredCap, expiredHoldLines, slotsLine, orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
 import { addHold, releaseHold } from './orchestrate/registry.js';
-import { activeLock, REPO_LOCK } from './orchestrate/lock.js';
-import { INTEGRATION_LOCK } from './orchestrate/integrate.js';
-import { mainTreeWorkers } from './orchestrate/main-tree.js';
+import { waveHolding, warnIntegrating, warnWaveWorking } from './repo-busy.js';
 import { cadenceHome, liveWaves, openLotsIn, openWavesIn, waveLotsIn } from './orchestrate/registry.js';
 import { blockingLots, LABEL, resumeCommand } from './orchestrate/table.js';
 import { renderTestsSansCode, testsSansCode } from './corrections-sans-code.js';
 import { bugCodeOf, bugCodePasses, classifyAll, classifySous, measure, ollamaClassifier, ollamaSousClassifier, readCache, readJournals, readRuns, readSousCache, renderReport, sampleKeys, serializeCache, serializeSousCache } from './corrections.js';
 import { computePerf, perfHeader, perfWindows, readPlans, readProjectDeliveries, readProjectFailedEntries, renderPerf } from './perf.js';
-import { findAcceptation, parseAcceptation, redAcceptations, resealAcceptation, resealForGreen, runAcceptation, setVert } from './orchestrate/accept.js';
+import { findAcceptation, parseAcceptation, redAcceptations, resealAcceptation, resealForGreen, runAcceptation, modeSpecGreen, setVert } from './orchestrate/accept.js';
 import { refCommand } from './ref/command.js';
 import { coverageCommand } from './ref/coverage.js';
 import { release } from './release.js';
 import { applyMigration, describeMigration, planMigration, unhandledError } from './migrate.js';
 import { checkFiche, deriveQa, readFiche, summary } from './spec.js';
+import { localCommand, localLotOf, localOverdueLines } from './local-task.js';
 import { readHudContext } from './hud-context.js';
 import { sessionClose, sessionStart } from './session.js';
 import { clearNext, readNext, sharedStateDir, stateDir, writeNext } from './state.js';
 const HELP = `raf — plan « reste à faire » versionné dans le dépôt, relié aux commits
 
   raf init [--project nom] [--prefix L] [--no-hook]
-  raf add "titre" [--estimate j] [--quickwin] [--visible [--screen page|component|journey]] [--spec] [--public "titre public"] [--every jours] [--after L2,L4] [--uses banc,passerelle] [--parent L3]
+  raf add "titre" [--estimate j] [--quickwin] [--visible [--screen page|component|journey]] [--spec] [--local] [--public "titre public"] [--every jours] [--after L2,L4] [--uses banc,passerelle] [--parent L3]
   raf public <id> "titre public" | --clear   titre du lot dans le langage du public (pages Nouveautés et Plan)
   raf screen <id> page|component|journey|none   pose, remplace ou retire screen: d'un lot visible existant (seule la valeur page adopte l'étape spec d'orchestrate)
   raf visible <id> on|off   pose ou retire visible: d'un lot existant (changement visible : entrée Nouveautés et étape UX d'orchestrate) ; off est refusé tant que le lot a un screen:
   raf spec <id> on|off   pose ou retire spec: d'un lot existant (le lot change un comportement : étape spec back d'orchestrate)
   raf move <id> --before|--after <id>   réordonne un lot (ou une sous-tâche) dans le plan, parmi ceux du même parent ; refusé pendant une vague du dépôt, sur un lot archivé et sur un plan en lecture seule
   raf uses <lot> [<ressource>…]   remplace les ressources partagées du lot (uses:, déclarées par resources: dans le cadence.yaml du dossier parent ; raf check refuse un nom non déclaré) ; sans nom, retire la clé
+  cadence local start <lot> [--ttl minutes] | local done <lot> | local abort <lot>   tâche locale du lead (lot posé par raf add --local) : start verrouille le dépôt comme une vague (aucune vague n'y démarre, --add y est refusé) et passe le lot à doing, refusé si une orchestration ou un autre lot du dépôt est en cours ; le verrou est déclaré (60 min par défaut), tenu sans processus jusqu'à done ou abort, signalé en ⚠ par lead tour et orchestrate --status au-delà du délai ; done joue la porte du projet UNE fois, libère le dépôt si elle est verte (la capture, la revue du diff, cadence deliver et raf done restent au lead) et le garde verrouillé sinon ; abort libère sans porte
   raf start <id>        raf done <id> [--force]        raf drop <id> [--reason texte]
   raf todo <id> [--reason texte]   remet en attente un lot démarré sans commit de travail (doing → todo, started retiré, note datée) ; refusé s'il a des commits ; rouvre un lot done ou dropped (→ todo, finished retiré, note « rouvert ») — la seule façon de rouvrir, archivé compris (il revient dans le fichier du plan)
   raf note <id> "texte"
@@ -175,6 +175,7 @@ function dispatch(argv, io) {
             visible: { type: 'boolean' },
             screen: { type: 'string' },
             spec: { type: 'boolean' },
+            local: { type: 'boolean' },
             public: { type: 'string' },
             every: { type: 'string' },
             dir: { type: 'string' },
@@ -282,7 +283,8 @@ function dispatch(argv, io) {
             if (free)
                 io.out(free);
             // une session du lead dont le TTL est échu (L278) : rien ne l'arrête, le tour la signale (hors --json, comme les créneaux)
-            for (const l of expiredHoldLines(io.now()))
+            // … et une tâche locale (L519) au-delà de son délai : le dépôt reste verrouillé, le tour le dit au lieu de le libérer en silence
+            for (const l of [...expiredHoldLines(io.now()), ...localOverdueLines(tourRoots(parent, depth), io.now())])
                 io.out(l);
             // le réglage lead.ux du cadence.yaml du dossier (L197) : le lead lit ici qui pose le verdict UX, au lieu d'ouvrir le fichier
             try {
@@ -396,14 +398,10 @@ function dispatch(argv, io) {
             const plan = loadPlan();
             let id;
             if (values.parent) {
-                if (values.screen !== undefined)
-                    throw new RafError('--screen se pose sur un lot, pas sur une sous-tâche');
-                if (values.spec)
-                    throw new RafError('--spec se pose sur un lot, pas sur une sous-tâche');
-                if (values.public !== undefined)
-                    throw new RafError('--public se pose sur un lot, pas sur une sous-tâche');
-                if (values.every !== undefined)
-                    throw new RafError('--every se pose sur un lot, pas sur une sous-tâche');
+                for (const [flag, given] of [['screen', values.screen !== undefined], ['spec', values.spec], ['local', values.local], ['public', values.public !== undefined], ['every', values.every !== undefined]]) {
+                    if (given)
+                        throw new RafError(`--${flag} se pose sur un lot, pas sur une sous-tâche`);
+                }
                 if (values.uses !== undefined)
                     throw new RafError(`uses se pose sur un lot, pas sur une sous-tâche : ${values.parent}`);
                 id = plan.addTask(values.parent, rest.join(' '));
@@ -421,7 +419,7 @@ function dispatch(argv, io) {
                 const uses = values.uses?.split(',').map((n) => n.trim()).filter(Boolean);
                 if (uses?.length === 0)
                     throw new RafError(invalidResource(''));
-                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, screen: values.screen, spec: values.spec, public: values.public, every, after, uses });
+                id = plan.add(rest.join(' '), today, { estimate, quickwin: values.quickwin, visible: values.visible, screen: values.screen, spec: values.spec, local: values.local, public: values.public, every, after, uses });
             }
             plan.save();
             io.out(id);
@@ -560,7 +558,7 @@ function dispatch(argv, io) {
             const plan = loadPlan();
             plan.move(rest[0], place, values[place]); // en mémoire : les refus de la commande (plan en lecture seule, parent, archive) passent avant celui de la vague
             // Un lot de la vague s'appuie sur l'ordre du plan qu'il a lu : le réordonner sous ses pieds est refusé tant que la vague tient le dépôt.
-            const holding = waveHolding(root);
+            const holding = waveHolding(root, 'move');
             if (holding)
                 throw new RafError(`move : orchestration en cours (vague ${holding.wave}, pid ${holding.pid}) — attendre que les lots de ce dépôt soient finis (le verrou tombe dès que tous sont prêts ou rendus), puis relancer`);
             plan.save();
@@ -793,7 +791,7 @@ function dispatch(argv, io) {
         case 'deliver': {
             if (!gitRoot(io.cwd))
                 throw new RafError('deliver : à lancer dans un dépôt git');
-            const orchestrating = waveHolding(root);
+            const orchestrating = waveHolding(root, 'deliver');
             if (orchestrating) {
                 const refusal = `deliver : orchestration en cours (vague ${orchestrating.wave}, pid ${orchestrating.pid})`;
                 if (values.sha === undefined)
@@ -858,6 +856,8 @@ function dispatch(argv, io) {
             io.out(base);
             return 0;
         }
+        case 'local':
+            return localCommand(rest, values.ttl, { repo: gitRoot(root) ?? root, loadPlan, today, now: io.now, gate: (sha) => verifyGateCommand({ sha }, io), out: io.out, err: io.err });
         case 'news':
             return news(rest, loadPlan(), newsDir, today, values, io, refuseLongTitle, () => hypothesesOf(root, configPath));
         default:
@@ -1164,7 +1164,8 @@ function prePush(root, io, remoteName, configPath, planFile) {
         return 0;
     }
     const holding = waveHolding(root);
-    if (holding) {
+    // Une tâche locale du lead (L519) tient le dépôt comme une vague, mais n'a pas de lots de vague : rien à vérifier pour la première garde, et pas de faux « état illisible ».
+    if (holding && !localLotOf(holding.wave)) {
         const lots = waveLotsIn(cadenceHome(), holding.pid, root);
         if (lots === null) {
             io.err(`raf: vague ${holding.wave} : état illisible, push non vérifié`);
@@ -1196,44 +1197,6 @@ function prePush(root, io, remoteName, configPath, planFile) {
     io.err(`raf: ${refusal}`);
     return REFUSED;
 }
-/**
- * Avertit (stderr, sans refuser) quand une intégration du dépôt est en cours (L425) : le plan écrit dans l'arbre principal est un fichier suivi modifié, et
- * l'intégration en cours le voit et refuse son lot (« arbre du dépôt modifié »). Seul l'arbre principal est concerné : dans le worktree d'un lot, l'écriture
- * ne change pas l'arbre que l'intégration contrôle.
- */
-function warnIntegrating(root, err) {
-    const top = gitRoot(root);
-    if (!top || !statSync(join(top, '.git')).isDirectory())
-        return;
-    const holder = activeLock(join(sharedStateDir(root), INTEGRATION_LOCK));
-    if (holder)
-        err(`avertissement : intégration en cours (vague ${holder.wave}, pid ${holder.pid}) — ce plan est un fichier suivi modifié de l'arbre principal, l'intégration en cours peut refuser son lot (arbre du dépôt modifié) : committer le plan sans attendre`);
-}
-/**
- * Avertit (stderr, sans refuser) quand une session de vague écrit dans l'arbre principal du dépôt (L475) : un lot en implémentation, revue ou correction sans worktree.
- * Un commit de plan du lead à ce moment-là rend le lot (cas du 30-10 : cadence L458 rendu par le commit du plan). Sans effet dans le worktree d'un lot, ou depuis une session de la vague (c'est elle qui tient l'arbre).
- */
-function warnWaveWorking(root, env, err) {
-    if (env.CADENCE_ORCHESTRATED)
-        return;
-    const top = gitRoot(root);
-    if (!top || !statSync(join(top, '.git')).isDirectory())
-        return;
-    const holder = activeLock(join(sharedStateDir(root), REPO_LOCK));
-    if (!holder)
-        return;
-    const working = mainTreeWorkers(cadenceHome(), holder.pid, top);
-    if (working?.length)
-        err(`avertissement : la vague ${holder.wave} (pid ${holder.pid}) travaille dans l'arbre principal de ce dépôt (${working.join(', ')}) — un commit de plan maintenant rendrait ces lots à la revue ; attendre la fin de leur étape, ou écrire le plan sans le committer`);
-}
-/** La vague qui tient le verrou du dépôt tant qu'un de ses lots y travaille encore (état illisible : on la tient pour active) ; null si le dépôt est libre. Partagé par `deliver` et `spec reseal`. */
-function waveHolding(root) {
-    const orchestrating = activeLock(join(sharedStateDir(root), REPO_LOCK));
-    if (!orchestrating)
-        return null;
-    const stillOpen = openLotsIn(cadenceHome(), orchestrating.pid, root);
-    return stillOpen === null || stillOpen.length > 0 ? orchestrating : null;
-}
 /**
  * `cadence spec reseal <lot> <test> --reason texte` (L200) : le chemin du lead quand un test d'acceptation scellé du lot EN COURS contredit la fiche.
  * Le test est corrigé dans l'arbre de travail (fiche inchangée, ou amendée et commitée par des commits du lot, L217) ; la commande refait l'empreinte de ce seul test, journalise la raison dans
@@ -1305,7 +1268,9 @@ function specGreen(args, ctx, io) {
     const doc = parseAcceptation(readFileSync(join(repo, json), 'utf8'));
     if (typeof doc === 'string')
         throw new RafError(`${json} : ${doc}`);
-    if (doc.vert) {
+    // Vert mais sans empreintes (L526, issue #20) : clos avant le scellement, il tient le verrou total sans qu'aucun chemin ne le scelle. On rejoue l'acceptation et, verte, on pose les empreintes.
+    const mode = modeSpecGreen(doc);
+    if (mode.deja) {
         io.out(`${lotId} : ${json} est déjà vert, rien à faire`);
         return 0;
     }
@@ -1320,25 +1285,26 @@ function specGreen(args, ctx, io) {
         throw new RafError(`fichiers listés dans ${json} sous la racine d'aucune commande de orchestrate.accept : ${orphans.join(', ')}`);
     const failed = runs.filter((r) => r.code !== 0);
     if (failed.length) {
-        io.err(`${lotId} : tests d'acceptation encore rouges (${failed.map((r) => `${r.command}, code ${r.code}`).join(' ; ')}), ${json} reste à vert: false`);
+        io.err(`${lotId} : tests d'acceptation encore rouges (${failed.map((r) => `${r.command}, code ${r.code}`).join(' ; ')}), ${json} ${mode.reste}`);
         for (const r of failed)
             io.err(r.output.trim().split('\n').slice(-40).join('\n'));
         return 1;
     }
     const before = readFileSync(join(repo, json), 'utf8');
-    let resceles;
+    let sealed;
     try {
-        resceles = resealForGreen(repo, json, ctx.today);
+        sealed = resealForGreen(repo, json, ctx.today);
     }
     catch (e) {
         throw new RafError(`${lotId} : ${e.message}`);
     }
-    setVert(repo, json);
+    const resceles = sealed.refaits;
+    setVert(repo, json); // déjà vrai pour un lot vert sans empreintes : le fichier garde ce qu'il avait
     try {
         git(repo, ['add', '--', json]);
         // Le sujet reste court et fixe (le gabarit `plan.commit` du projet s'il y en a un, comme tout commit écrit par cadence, L343) ; les tests rescellés, sans borne, vont dans le corps, une ligne chacun.
         const template = readPlanConfig(join(repo, 'cadence.yaml'), repo)?.commit;
-        const subject = template ? planCommitMessage(template, { lot: lotId, action: PLAN_ACTIONS.specGreen }) : `chore(${lotId}): ${PLAN_ACTIONS.specGreen}`;
+        const subject = template ? planCommitMessage(template, { lot: lotId, action: mode.action }) : `chore(${lotId}): ${mode.action}`;
         const body = resceles.length ? ['empreintes rescellées (tests mis au point depuis le commit rouge) :', ...resceles.map((f) => `- ${f}`)].join('\n') : null;
         git(repo, ['commit', '-q', '-m', subject, ...(body ? ['-m', body] : []), '--', json]);
     }
@@ -1354,14 +1320,14 @@ function specGreen(args, ctx, io) {
         const out = e;
         throw new RafError(`spec green : le commit a échoué, ${json} est revenu tel qu'avant la commande — ${(out.stderr || out.stdout || out.message).trim().split('\n').slice(-5).join(' | ')}`);
     }
-    io.out(`${lotId} : ${json} → vert: true, commit ${git(repo, ['rev-parse', '--short', 'HEAD']).trim()}${resceles.length ? ` ; empreintes rescellées (tests mis au point depuis le commit rouge) : ${resceles.join(', ')}` : ''}`);
+    io.out(`${lotId} : ${json} → ${mode.fait}${sealed.scelles.length ? ` (${sealed.scelles.join(', ')})` : ''}, commit ${git(repo, ['rev-parse', '--short', 'HEAD']).trim()}${resceles.length ? ` ; empreintes rescellées (tests mis au point depuis le commit rouge) : ${resceles.join(', ')}` : ''}`);
     return 0;
 }
 /** Un commit du lead en pleine passe ferait signaler au lot suivant un écart qui n'est pas le sien : tant qu'une vague tient le verrou du dépôt, `spec reseal` et `spec green` refusent. */
 function refuseWhileWaveHolds(ctx, command) {
     // Comme `deliver` : la vague tient le verrou du dépôt tant qu'un de ses lots y travaille (état illisible : on refuse).
     // Le refus est UN message : la vague vivante qui tient le verrou (à attendre) et les vagues arrêtées du dépôt, avec leurs dossiers et leurs commandes (L238).
-    const orchestrating = waveHolding(ctx.root);
+    const orchestrating = waveHolding(ctx.root, command);
     if (orchestrating) {
         const repo = gitRoot(ctx.root) ?? ctx.root;
         let open = [];
@@ -1469,6 +1435,20 @@ function specReseal(args, reason, porteur, ctx, io) {
     io.out(`${lotId} : ${norm} rescellé (${r.avant.slice(0, 7)} → ${r.apres.slice(0, 7)}), commit ${sha}${r.ficheAmendee ? `, fiche amendée en ${r.ficheAmendee}` : ''} ; raison dans ${json} et en note du lot ${cite}${tracked ? '' : ' (plan à commiter)'}`);
     return 0;
 }
+/** Les racines git des projets du tour (la clé `depth:` du dossier, un seul niveau si elle est illisible : le tour a déjà sa ligne d'erreur). */
+function tourRoots(parent, depth) {
+    let levels = depth;
+    if (levels === undefined) {
+        try {
+            levels = readDepth(parent);
+        }
+        catch {
+            levels = 1;
+        }
+    }
+    const dirs = findProjects(parent, levels);
+    return (dirs.length === 0 && isProject(parent) ? [parent] : dirs).map((d) => gitRoot(d) ?? d);
+}
 /** Durée par défaut (minutes) d'une session du lead inscrite par `lead hold` : de quoi finir un correctif ou une revue, pas de quoi oublier la réservation toute la journée. */
 const HOLD_TTL_MINUTES = 60;
 /** Longueur maximale de l'étiquette encodée : un nom de fichier tient en 255 octets, `.json.tmp` en prend 9. */

package/dist/lead.js

@@ -3,6 +3,7 @@ import { basename, dirname, join, relative, sep } from 'node:path';
 import { audit, gateWaiting, nextUp, planCommits, workByLot } from './audit.js';
 import { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readPlanConfig } from './config.js';
 import { diffDays } from './dates.js';
+import { localRepoNotes } from './local-task.js';
 import { gitRoot, repoStatus } from './git.js';
 import { linkCommits } from './link.js';
 import { commitCount, lastActivity, lockStatus } from './session.js';
@@ -195,6 +196,7 @@ export function tourRow(dir, today, idle = TOUR_IDLE, name = basename(dir)) {
             row.repo.push('non poussé');
         if (lockStatus(sharedStateDir(root))?.live)
             row.repo.push('livraison en cours');
+        row.repo.push(...localRepoNotes(root, new Date()));
         const kept = keptTrees(root);
         if (kept.length)
             row.worktrees = kept;

package/dist/local-task.js

@@ -0,0 +1,143 @@
+import { basename, join } from 'node:path';
+import { REPO_LOCK, activeLock, lockOverdue, releaseLock, takeLock } from './orchestrate/lock.js';
+import { longDuration } from './orchestrate/guard.js';
+import { RafError } from './plan.js';
+import { tryGit } from './git.js';
+import { sharedStateDir } from './state.js';
+/** Nom de « vague » sous lequel la tâche locale d'un lot tient le verrou du dépôt : les refus des vagues le citent tel quel. */
+export const localWave = (lot) => `local:${lot}`;
+/** Le lot d'un verrou de tâche locale (`local:<lot>`), null pour le verrou d'une vague. */
+export const localLotOf = (wave) => (wave.startsWith('local:') ? wave.slice('local:'.length) : null);
+/** Durée annoncée (minutes) d'une tâche locale sans `--ttl` : celle de `lead hold` — de quoi finir une retouche, pas de quoi oublier le dépôt verrouillé toute la journée. */
+export const LOCAL_TTL_MINUTES = 60;
+const lockFile = (repo) => join(sharedStateDir(repo), REPO_LOCK);
+/** Le refus qu'un verrou tenu oppose à une tâche locale ou à une vague : une tâche locale est nommée comme telle, avec sa sortie. */
+export function heldRefusal(repo, held) {
+    const local = localLotOf(held.wave);
+    if (local)
+        return `${repoName(repo)} : une tâche locale du lead y est en cours (${local}, depuis ${held.started}) — la finir (cadence local done ${local}) ou l'abandonner (cadence local abort ${local})`;
+    return `${repoName(repo)} : une orchestration y est déjà en cours (${held.wave}, pid ${held.pid})`;
+}
+/**
+ * `cadence local start <lot>` : le lead va modifier lui-même ce dépôt pour un lot marqué `local`. Le dépôt est verrouillé comme par une vague (aucune vague n'y démarre,
+ * `--add` y est refusé par le même contrôle de dépôt) et le lot passe à `doing`. Le verrou est DÉCLARÉ (`until`) : le shell qui lance la commande meurt à la fin de l'appel de l'outil
+ * Bash et la session du lead (Claude desktop) n'a pas de nom de processus stable — aucun processus ne le porte, il tient jusqu'à `local done` ou `local abort`, et au TTL échu il se
+ * signale (⚠) au lieu de tomber. Refus (`RafError`, rien n'est verrouillé ni écrit ; si l'écriture du plan échoue, le verrou pris est relâché) : lot inconnu, non marqué local, déjà
+ * fini, une orchestration ou une autre tâche locale qui tient le dépôt, un autre lot du dépôt en cours.
+ */
+export function startLocal(repo, plan, lotId, d) {
+    const lot = plan.lots().find((l) => l.id === lotId);
+    if (!lot)
+        throw new RafError(`lot inconnu : ${lotId}`);
+    if (!lot.local)
+        throw new RafError(`${lotId} n'est pas marqué local : le lead ne modifie pas lui-même le dépôt pour un lot de vague (raf add --local pour en créer un)`);
+    if (lot.status === 'done' || lot.status === 'dropped')
+        throw new RafError(`${lotId} est ${lot.status} : une tâche locale ne reprend pas un lot fini`);
+    const held = activeLock(lockFile(repo));
+    if (held)
+        throw new RafError(held.wave === localWave(lotId) ? `${lotId} : la tâche locale est déjà en cours (depuis ${held.started}) — cadence local done ${lotId} à sa fin` : `${heldRefusal(repo, held)} — attendre sa fin`);
+    const others = plan.lots().filter((l) => l.status === 'doing' && l.id !== lotId);
+    if (others.length)
+        throw new RafError(`${repoName(repo)} : un lot du dépôt est en cours (${others.map((l) => l.id).join(', ')}) — le finir, ou raf todo, avant la tâche locale`);
+    const now = d.now();
+    const until = new Date(now.getTime() + (d.ttlMinutes ?? LOCAL_TTL_MINUTES) * 60_000).toISOString();
+    const taken = takeLock(lockFile(repo), { pid: d.pid, wave: localWave(lotId), started: now.toISOString(), until });
+    if (!taken.ok)
+        throw new RafError(`${heldRefusal(repo, taken.held)} — attendre sa fin`);
+    if (lot.status === 'todo') {
+        try {
+            plan.setStatus(lotId, 'doing', d.today);
+            plan.save();
+        }
+        catch (e) {
+            releaseLock(lockFile(repo), d.pid);
+            throw e;
+        }
+    }
+}
+/** Le verrou de la tâche locale de `lotId` s'il tient le dépôt ; `RafError` sinon (dépôt libre, vague, ou tâche d'un autre lot). */
+function localHeld(repo, lotId) {
+    const held = activeLock(lockFile(repo));
+    if (!held || held.wave !== localWave(lotId))
+        throw new RafError(`aucune tâche locale en cours pour ${lotId} (cadence local start ${lotId})`);
+    return held;
+}
+/**
+ * `cadence local done <lot>` : la tâche locale du lead est finie. La porte du projet est jouée UNE fois ; verte, le verrou tombe (la capture, la revue du diff par le lead,
+ * la livraison et `raf done` restent au lead, dans cet ordre) ; rouge ou sans verdict, le verrou reste : le lead corrige et rejoue. Refus (`RafError`) quand ce n'est pas la tâche locale de ce lot qui tient le dépôt.
+ */
+export async function finishLocal(repo, lotId, d) {
+    const held = localHeld(repo, lotId);
+    const code = await d.gate();
+    if (code === 1) {
+        d.err(`${lotId} : porte rouge — le dépôt reste verrouillé ; corriger, puis cadence local done ${lotId}`);
+        return 1;
+    }
+    if (code !== 0) {
+        d.err(`${lotId} : la porte n'a rien rejoué (orchestrate.build / orchestrate.test absents ?) — le dépôt reste verrouillé`);
+        return 2;
+    }
+    releaseLock(lockFile(repo), held.pid);
+    d.out(`${lotId} : porte verte, dépôt libéré. Suite : la capture d'un lot visible, relire le diff du lot et poser son verdict (raf review ${lotId} "…" — raf done le demande), cadence deliver, puis raf done ${lotId}`);
+    return 0;
+}
+/** `cadence local abort <lot>` : lève le verrou de la tâche locale sans jouer la porte ; le plan n'est pas touché (le lot reste `doing` : `raf todo <lot>` pour l'abandonner). */
+export function abortLocal(repo, lotId, out = () => { }) {
+    const held = localHeld(repo, lotId);
+    releaseLock(lockFile(repo), held.pid);
+    out(`${lotId} : tâche locale abandonnée, dépôt libéré sans porte ; le lot reste doing (raf todo ${lotId} pour le remettre à todo)`);
+}
+/**
+ * Une ligne ⚠ par dépôt dont une tâche locale a dépassé son TTL à `now` (lead tour, orchestrate --status) : le verrou tient toujours, le lead le finit ou l'abandonne. Vide sans tâche échue.
+ * Un dépôt illisible est sauté.
+ */
+export function localOverdueLines(repos, now) {
+    const lines = [];
+    for (const repo of new Set(repos)) {
+        let held;
+        try {
+            held = activeLock(lockFile(repo));
+        }
+        catch {
+            continue;
+        }
+        const lot = held && localLotOf(held.wave);
+        if (!held || !lot || !lockOverdue(held, now))
+            continue;
+        const since = Date.parse(held.started);
+        const age = Number.isFinite(since) ? `démarrée depuis ${longDuration(now.getTime() - since)}, ` : '';
+        lines.push(`⚠ tâche locale échue : ${lot} (${basename(repo)} · ${age}échue depuis ${longDuration(now.getTime() - Date.parse(held.until))}) — le dépôt reste verrouillé : la finir (cadence local done ${lot}) ou l'abandonner (cadence local abort ${lot})`);
+    }
+    return lines;
+}
+/** Ce que le tableau du lead dit du dépôt : « tâche locale L1 », avec « (échue) » au TTL passé ; vide sans tâche locale. */
+export function localRepoNotes(repo, now) {
+    const held = activeLock(lockFile(repo));
+    const lot = held && localLotOf(held.wave);
+    return held && lot ? [`tâche locale ${lot}${lockOverdue(held, now) ? ' (échue)' : ''}`] : [];
+}
+/** Le refus qu'un lot local oppose à une vague (lancement, `--add`, `--continue`) : il est au lead ; null pour un lot de vague. */
+export const localLotRefusal = (lot) => (lot.local ? `lot local (raf add --local) : le lead le fait lui-même (cadence local start ${lot.id}), une vague ne le joue pas` : null);
+const repoName = (repo) => repo.split('/').filter(Boolean).pop() ?? repo;
+/** `cadence local start|done|abort <lot> [--ttl minutes]` : l'analyse de la commande, puis `startLocal`, `finishLocal` ou `abortLocal` ; `gate(sha)` joue la porte du projet au sha. */
+export async function localCommand(rest, ttl, c) {
+    const usage = 'usage : cadence local start <lot> [--ttl minutes] | cadence local done <lot> | cadence local abort <lot>';
+    if (rest.length !== 2 || (rest[0] !== 'start' && rest[0] !== 'done' && rest[0] !== 'abort'))
+        throw new RafError(usage);
+    const [sub, lot] = rest;
+    if (ttl !== undefined && sub !== 'start')
+        throw new RafError(`--ttl ne va qu'avec local start (${usage})`);
+    const minutes = ttl === undefined ? undefined : Number(ttl);
+    if (minutes !== undefined && !(Number.isInteger(minutes) && minutes >= 1))
+        throw new RafError(`--ttl invalide : ${ttl} (un nombre entier de minutes ≥ 1)`);
+    const deps = { ...c, pid: process.pid, ttlMinutes: minutes, gate: () => c.gate(tryGit(c.repo, ['rev-parse', 'HEAD']) ?? 'HEAD') };
+    if (sub === 'done')
+        return finishLocal(c.repo, lot, deps);
+    if (sub === 'abort') {
+        abortLocal(c.repo, lot, c.out);
+        return 0;
+    }
+    startLocal(c.repo, c.loadPlan(), lot, deps);
+    c.out(`${lot} : dépôt verrouillé (tâche locale, ${minutes ?? LOCAL_TTL_MINUTES} min annoncées) — aucune vague n'y démarre, le verrou tient jusqu'à cadence local done ${lot} (ou local abort ${lot}) ; au-delà du délai il se signale en ⚠`);
+    return 0;
+}

package/dist/orchestrate/accept.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, posix } from 'node:path';
 import { parse } from 'yaml';
 import { citedRefs } from '../link.js';
+import { PLAN_ACTIONS } from '../plan-commit.js';
 import { isParts } from './gate-parts.js';
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function git(repo, ...args) {
@@ -215,7 +216,8 @@ export function runAcceptation(repo, json, accept) {
 /**
  * `cadence spec green` (L366) : la commande d'acceptation vient de passer au vert sur les tests tels qu'ils sont. Ceux qu'un lot mené à la main a mis au point
  * après le commit rouge ont une empreinte scellée périmée : le verrou les signalerait encore à chaque lot suivant. Chaque empreinte différente est refaite et
- * journalisée dans `resceaux` (comme `spec reseal`, sans fiche amendée) ; le commit qui pose `vert: true` devient ainsi le commit rouge. Rend les tests rescellés.
+ * journalisée dans `resceaux` (comme `spec reseal`, sans fiche amendée) ; le commit qui pose `vert: true` devient ainsi le commit rouge. Un test SANS empreinte (lot clos avant le scellement, L526)
+ * n'a rien de périmé : il est scellé (`sealAcceptation`, sans entrée de journal). Rend les tests rescellés (`refaits`) et ceux qui viennent d'être scellés (`scelles`).
  * L'appelant s'est assuré que les tests listés sont commités (l'empreinte rescellée est celle de l'arbre de travail) ; un test absent est refusé.
  */
 export function resealForGreen(repo, path, today) {
@@ -223,25 +225,38 @@ export function resealForGreen(repo, path, today) {
     const a = parseAcceptation(readFileSync(file, 'utf8'));
     if (typeof a === 'string')
         throw new Error(`${path} : ${a}`);
-    const fichiers = a.fichiers.map((f) => posix.normalize(f));
+    const fichiers = [...new Set(a.fichiers.map((f) => posix.normalize(f)))];
     const absents = fichiers.filter((f) => !existsSync(join(repo, f)));
     if (absents.length)
         throw new Error(`test(s) listé(s) absent(s) de ${path} : ${absents.join(', ')}`);
     const doc = JSON.parse(readFileSync(file, 'utf8'));
     const empreintes = isObj(doc.empreintes) ? doc.empreintes : {};
     const journal = Array.isArray(doc.resceaux) ? doc.resceaux : [];
-    const refaits = fichiers.filter((f) => empreintes[f] !== git(repo, 'hash-object', '--', f).trim());
+    const scelles = fichiers.filter((f) => !empreintes[f]);
+    const refaits = fichiers.filter((f) => empreintes[f] && empreintes[f] !== git(repo, 'hash-object', '--', f).trim());
+    for (const f of scelles)
+        empreintes[f] = git(repo, 'hash-object', '--', f).trim();
     for (const f of refaits) {
         const apres = git(repo, 'hash-object', '--', f).trim();
-        journal.push({ test: f, raison: 'cadence spec green : tests mis au point après le commit rouge, acceptation verte sur ces tests', date: today, avant: empreintes[f] ?? '', apres });
+        journal.push({ test: f, raison: 'cadence spec green : tests mis au point après le commit rouge, acceptation verte sur ces tests', date: today, avant: empreintes[f], apres });
         empreintes[f] = apres;
     }
-    if (refaits.length) {
+    if (refaits.length || scelles.length) {
         doc.empreintes = empreintes;
-        doc.resceaux = journal;
+        if (refaits.length)
+            doc.resceaux = journal;
         writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`);
     }
-    return refaits;
+    return { refaits, scelles };
+}
+/** Les fichiers listés qui n'ont pas d'empreinte scellée (L526 : lot clos à `vert: true` avant le scellement, ou scellé en partie). */
+export function sansEmpreinte(a) {
+    return a.fichiers.map((f) => posix.normalize(f)).filter((f) => !a.empreintes?.[f]);
+}
+/** Ce que `cadence spec green` fait d'une acceptation (L526) : rien si elle est verte et scellée ; sinon rejouer, puis poser `vert: true` (rouge) ou seulement les empreintes (verte, clos avant le scellement). */
+export function modeSpecGreen(a) {
+    const sansSceau = a.vert && sansEmpreinte(a).length > 0;
+    return { deja: a.vert && !sansSceau, action: sansSceau ? PLAN_ACTIONS.specGreenScelle : PLAN_ACTIONS.specGreen, reste: sansSceau ? 'reste sans empreintes' : 'reste à vert: false', fait: sansSceau ? 'empreintes posées' : 'vert: true' };
 }
 /** Pose `vert: true` dans le fichier (le cycle, jamais une session) ; le commit est à faire. */
 export function setVert(repo, path) {

package/dist/orchestrate/ajout.js

@@ -2,6 +2,7 @@ import { basename, join, relative, resolve } from 'node:path';
 import { lotFinished, lotKey, lotRepoPaths } from './state.js';
 import { cadenceHome, liveWaves } from './registry.js';
 import { REPO_LOCK, takeLock } from './lock.js';
+import { heldRefusal } from '../local-task.js';
 import { installPrePush } from './guard.js';
 import { sharedStateDir } from '../state.js';
 import { waveReadsAdds } from './snapshot.js';
@@ -116,7 +117,7 @@ export class AddFeed {
             return null;
         const l = takeLock(file, { pid: process.pid, wave: e.wave.id, started: new Date().toISOString() });
         if (!l.ok && l.held.pid !== process.pid)
-            return `${basename(repo)} : une orchestration y est déjà en cours (${l.held.wave}, pid ${l.held.pid})`;
+            return heldRefusal(repo, l.held);
         e.held.push(file);
         fresh.push(repo);
         if (l.ok && l.stale)

package/dist/orchestrate/briefs.js

@@ -53,6 +53,15 @@ export function newsText(lot, captureDir) {
         'Commit the entry with the lot (`cadence news check` must pass).',
     ].join('\n');
 }
+/** Consigne `{{express}}` du brief d'implémentation d'un lot express ; vide ailleurs. */
+export const EXPRESS_BRIEF = [
+    'Express lane (touch-up of at most 0.1 day): this is the only session of the lot. There is no precheck, no edge-case probe and no separate code review: the lead reads the diff and looks at the capture. So name the file and the scope you touched in your report, keep the diff to what the goal says, and do not widen it.',
+    'No new test for a purely visual change (the existing suite runs and must stay green); a change of behaviour still gets its test first. The full suite and the build run once, at the end.',
+].join('\n');
+/** Consigne `{{news}}` d'un lot express `visible` : pas d'entrée Nouveautés par lot, la capture seule (le lead regroupe les entrées à la livraison). */
+export function expressNewsText(captureDir) {
+    return `No News entry for this lot (express lane): the lead groups the entries at delivery. Do not run \`cadence news new\`. Take a capture of the result (it lands in the wave's output directory, \`${captureDir}\`): the lead looks at it instead of a separate review.`;
+}
 /** Consigne des briefs de correction d'un lot `visible` : où la vague range les captures Playwright (même dossier que l'étape implement). */
 export function capturesText(captureDir) {
     return `A Playwright capture taken with the absolute path given above lands in \`${captureDir}\` (outside the repository; this session may read it): a screenshot a finding asks for is copied from there into \`docs/nouveautes/captures/\`.`;
@@ -117,6 +126,8 @@ const FILES = {
     'review-small': 'review-small.md',
     'review-recheck': 'review-recheck.md',
 };
+/** Les variables dont l'absence se rend par un texte vide : le brief d'une étape qui n'en a pas l'usage ne les fournit pas. */
+const BLANK_WHEN_ABSENT = ['repos', 'integration', 'docs', 'elsewhere', 'ack', 'spec', 'decisions', 'accept', 'maquette', 'tmp', 'workers', 'gate', 'shots', 'fiche', 'express'];
 /** Lit tous les gabarits du dossier. Un gabarit absent est une erreur, avant que quoi que ce soit ne parte. */
 export function loadTemplates(dir = TEMPLATES_DIR) {
     const out = {};
@@ -137,7 +148,7 @@ export function loadTemplates(dir = TEMPLATES_DIR) {
 export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
     const text = typeof source === 'string' ? loadTemplates(source)[kind] : source[kind];
     const out = text.replace(/\{\{(\w+)\}\}/g, (_m, name) => {
-        const v = { ...vars, repos: vars.repos ?? '', integration: vars.integration ?? '', docs: vars.docs ?? '', elsewhere: vars.elsewhere ?? '', ack: vars.ack ?? '', spec: vars.spec ?? '', decisions: vars.decisions ?? '', accept: vars.accept ?? '', maquette: vars.maquette ?? '', tmp: vars.tmp ?? '', workers: vars.workers ?? '', gate: vars.gate ?? '', shots: vars.shots ?? '', fiche: vars.fiche ?? '', lecture: vars.lecture ?? PLAN_READING }[name];
+        const v = { ...vars, ...Object.fromEntries(BLANK_WHEN_ABSENT.map((k) => [k, vars[k] ?? ''])), lecture: vars.lecture ?? PLAN_READING }[name];
         if (v === undefined)
             throw new RafError(`gabarit ${FILES[kind]} : valeur manquante pour {{${name}}}`);
         return v;

package/dist/orchestrate/command.js

@@ -8,6 +8,7 @@ import { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readOrchestrateConfig, readPlanC
 import { PLAN_ACTIONS, commitMsgHook, leadAnswerMessage, commitMsgRefusal, planCommitMessage } from '../plan-commit.js';
 import { isDay, toDay } from '../dates.js';
 import { gitRoot } from '../git.js';
+import { heldRefusal, localLotRefusal, localOverdueLines } from '../local-task.js';
 import { onTermination } from '../proc.js';
 import { stopApps } from './app.js';
 import { RafError, isOpen } from '../plan.js';
@@ -39,6 +40,7 @@ import { baseBranchOf, keptLines, lotBranch, lotTreeDir, planFileSet, recoverTre
 import { agentOf, schemaFor } 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';
 import { linkNodeBin, nvmVersionsDir, resolveNode } from './node-env.js';
 import { quotaText, renderDetail, renderTable, resumeCommand } from './table.js';
 import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveModulesDir, repairSnapshotModules, snapshotExists, waveReadsAnswerQueue, waveReadsControl, waveReadsIntegrate, waveReadsLotBudget, waveReadsReplay, withoutLaunchVars, spawnReexec, takeSnapshot, toolDirOf } from './snapshot.js';
@@ -274,8 +276,9 @@ export async function preflight(args, targets, io, deps, launch, opts = {}) {
             refusals.push(`${key} : lot inconnu`);
             continue;
         }
-        if (!isOpen(lot.status)) {
-            refusals.push(`${key} : le lot est ${lot.status}`);
+        const shut = !isOpen(lot.status) ? `le lot est ${lot.status}` : localLotRefusal(lot); // un lot local (L519) est au lead, jamais à une vague
+        if (shut) {
+            refusals.push(`${key} : ${shut}`);
             continue;
         }
         if (plan.readonly && lot.status === 'todo' && !env.config.start) {
@@ -322,6 +325,8 @@ export async function preflight(args, targets, io, deps, launch, opts = {}) {
         if (neighbours.repos.length)
             state.repos = neighbours.repos;
         state.estimate = lot.estimate;
+        if (isExpress({ estimate: lot.estimate, screen, specLot: state.specLot }))
+            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);
@@ -334,9 +339,7 @@ export async function preflight(args, targets, io, deps, launch, opts = {}) {
     }
     return { refusals, lots };
 }
-function agentsOf(deps) {
-    return readAgents(deps.agentsDir);
-}
+const agentsOf = (deps) => readAgents(deps.agentsDir);
 const WAVE_ID_RE = /^[\w.-]+$/;
 /** Identifiant par défaut : jour et minute de lancement ; le suffixe qui départage deux vagues vient de `RunStore.reserve`. */
 function defaultWaveBase(io) {
@@ -463,23 +466,26 @@ function dryRun(lots, io, deps, budget, id) {
             steps.unshift({ kind: 'fiche', model: 'sonnet' });
         if (specStage)
             steps.unshift({ kind: 'spec', model: 'sonnet' });
-        if (needsPrecheck(env.config, env.loadPlan(), l.repo, l.lot, l.repos, l.goal)) {
+        if (!l.express && needsPrecheck(env.config, env.loadPlan(), l.repo, l.lot, l.repos, l.goal)) {
             const nothingToFind = precheckNothingToFind(env.loadPlan(), l.repo, l.lot, l.repos, l.goal);
             if (nothingToFind)
                 io.out(`  contrôle préalable sauté : ${nothingToFind}`);
             else
                 steps.unshift({ kind: 'precheck', model: env.config.precheckLocal ? 'local' : 'sonnet' });
         }
-        steps.push(...(env.config.probe ? [{ kind: 'probe', model: 'sonnet' }] : [])); // L497 : entre l'écriture et la revue
+        steps.push(...(env.config.probe && !l.express ? [{ kind: 'probe', model: 'sonnet' }] : [])); // L497 : entre l'écriture et la revue
         const { light, full } = env.config.review;
-        if (l.small)
+        if (l.express) {
+            // L519 : une seule session, le lead lit le diff
+        }
+        else if (l.small)
             steps.push({ kind: l.visible ? 'review-small' : 'review', model: l.light ? light : full });
         else {
             steps.push({ kind: 'review', model: l.light ? light : full });
             if (l.visible && env.config.ux)
                 steps.push({ kind: 'ux', model: full }); // L221 : l'UX est jouée une fois, après la revue de code conforme
         }
-        io.out(`  étapes : ${steps.map((s) => `${s.kind} (${s.model})`).join(' → ')}${l.small ? ' — petit lot' : ''}${l.light ? ` — revue légère (${light}, pas de passe des mineurs ; un bloquant ou un majeur → correction puis revue ${full})` : ''}${l.visible && !env.config.ux ? ' — UX à faire par le lead (orchestrate.ux absent)' : ''}`);
+        io.out(`  étapes : ${steps.map((s) => `${s.kind} (${s.model})`).join(' → ')}${l.small ? ' — petit lot' : ''}${l.express ? ' — voie express (pas de précheck, de sonde ni de revue séparée : le lead lit le diff)' : ''}${l.light && !l.express ? ` — revue légère (${light}, pas de passe des mineurs ; un bloquant ou un majeur → correction puis revue ${full})` : ''}${l.visible && !env.config.ux ? ' — UX à faire par le lead (orchestrate.ux absent)' : ''}`);
         for (const m of new Set(steps.map((s) => s.model))) {
             if (m !== 'local' && !MODEL_ALIASES.includes(m))
                 io.out(`  ⚠ modèle « ${m} » hors des alias ${MODEL_ALIASES.join(', ')} : passé tel quel à claude --model (un nom que le compte ne connaît pas fait échouer la session)`);
@@ -592,7 +598,7 @@ const ANSWER_POLL_MS = 2000;
 function statusView(args, launch, cap, now) {
     const id = statusWave(args);
     const store = id !== undefined ? RunStore.find(launch, id) : RunStore.last(launch);
-    const live = [...liveLines(cap, now), ...expiredHoldLines(now)];
+    const live = [...liveLines(cap, now), ...expiredHoldLines(now), ...localOverdueLines((isLeadProject(launch) ? [launch] : findProjects(launch)).map((d) => gitRoot(d) ?? d), now)];
     const waveLive = liveWaves(cadenceHome()).length > 0;
     if (!store && live.length && id === undefined)
         return { live, running: waveLive };
@@ -1082,7 +1088,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         const l = takeLock(file, { pid: process.pid, wave: wave.id, started: new Date().toISOString() });
         // Le verrou déjà à ce pid : pris par la reprise qui a attendu l'autre vague (L443).
         if (!l.ok && l.held.pid !== process.pid) {
-            io.err(`orchestrate : ${basename(r)} : une orchestration y est déjà en cours (${l.held.wave}, pid ${l.held.pid})`);
+            io.err(`orchestrate : ${heldRefusal(r, l.held)}`);
             release();
             return 2;
         }
@@ -1653,7 +1659,7 @@ async function resume(args, argv, io, deps, launch, today) {
                 }
                 // Un refus déjà posé sur un dépôt précédent (même vague, attente échue) : les suivants ne font plus attendre, la reprise sort en 2.
                 if (!waitFor || refusals.length || Date.now() >= deadline) {
-                    refusals.push(`${basename(repo)} : une orchestration y est déjà en cours (${busy.wave}, pid ${busy.pid})`);
+                    refusals.push(heldRefusal(repo, busy));
                     break;
                 }
                 if (!waiting) {

package/dist/orchestrate/cycle.js

@@ -24,7 +24,7 @@ import { TEST_WORKERS_ENV, testWorkersText } from './workers.js';
 import { baselineCandidates, gateLabel, gateReplayable, gateUnnamed, redAloneGate, redCandidates, replayGate, runGate } from './gate-parts.js';
 import { withPlace } from './gate-place.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
-import { capturesText, gateText, headline, integrationText, localReading, precheckBrief, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, tiersText, tmpText } from './briefs.js';
+import { capturesText, EXPRESS_BRIEF, expressNewsText, gateText, headline, integrationText, localReading, precheckBrief, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, tiersText, tmpText } from './briefs.js';
 import { SlotAbandoned } from './registry.js';
 import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, trackGroup, writeMcpConfig, enabledPlugins, settingsFiles } from './launch.js';
 import { cleanPlaywrightOutput, pushed, remoteAdvances, snapshot } from './guard.js';
@@ -39,7 +39,7 @@ import { bulletLines, maquetteText, reviewedText } from './maquette.js';
 import { answeredText, checkSpec, costlyHypotheses, ficheHasBack, ficheReady, findFiche, hypothesisLines, answerAltersRule, hypothesisNote, LEAD_SOURCE, ruleIdsSourcedByLead, sourceRules, specText } from './spec.js';
 import { handBackWithoutFinding } from './no-finding.js';
 import { decisionsText, humanDecisions } from './decisions.js';
-import { LOCAL_PRECHECK_UNREADABLE, PRECHECK_UNREADABLE, lotKey, lotRepoPaths, neighbourDirs } from './state.js';
+import { LOCAL_PRECHECK_UNREADABLE, PRECHECK_UNREADABLE, expressSummary, lotKey, lotRepoPaths, neighbourDirs } from './state.js';
 import { advance, baseMoved, INTEGRATE_WAIT_MS, MAX_REPLAYS, mergeBase, patchId, rebaseOnto, repoBranch, takeRepoWrite } from './integrate.js';
 import { mutexFor } from './mutex.js';
 import { readTier, stillThird, takeTiers, tierMoved, tierRepos, wipBranch } from './tiers.js';
@@ -517,10 +517,10 @@ function briefFor(c, kind, local = false) {
     const l = c.lot;
     const lot = plan.lot(l.lot);
     const tmpDir = c.wave.store.tmpDir(l.project, l.lot);
-    const vars = { chemin: wd(c), lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', tmp: tmpText(tmpDir), workers: writesCode(kind) ? workersText(c) : '', gate: writesCode(kind) ? gateText(c.config) : '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []), integration: c.integration ? integrationText(c.integration.base) : '' };
+    const vars = { chemin: wd(c), lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', express: kind === 'implement' && l.express ? EXPRESS_BRIEF : '', tmp: tmpText(tmpDir), workers: writesCode(kind) ? workersText(c) : '', gate: writesCode(kind) ? gateText(c.config) : '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []), integration: c.integration ? integrationText(c.integration.base) : '' };
     if (l.visible) {
         const pwDir = playwrightDir(c.wave.store.lotDir(l.project, l.lot));
-        vars.news = newsText(l.lot, pwDir);
+        vars.news = l.express ? expressNewsText(pwDir) : newsText(l.lot, pwDir);
         vars.captures = capturesText(pwDir);
     }
     if (mcpServersFor(kind, l.visible, '', l.small, !!l.screen).playwright)
@@ -1411,7 +1411,7 @@ async function precheck(c) {
 /** Le lot passe-t-il par le contrôle préalable ? Un lot qui n'a rien à retrouver (L322) saute l'étape, et le journal du lot le dit. */
 function precheckOrSkip(c) {
     const plan = c.loadPlan();
-    if (!needsPrecheck(c.config, plan, c.lot.repo, c.lot.lot, c.lot.repos, c.lot.goal))
+    if (c.lot.express || !needsPrecheck(c.config, plan, c.lot.repo, c.lot.lot, c.lot.repos, c.lot.goal))
         return false;
     const nothing = precheckNothingToFind(histPlan(c), wd(c), c.lot.lot, c.lot.repos, c.lot.goal);
     if (nothing)
@@ -2293,7 +2293,7 @@ async function work(c, kind) {
     }
     // Porte « code modifié sans test » (L287) : le diff du lot (son dépôt et ses voisins, fichiers supprimés exclus), toutes sessions comprises, touche du code sans fichier de test → correction directe, sans session de revue. Une seule fois par lot, jamais pendant la passe des mineurs, ni quand la correction prendrait la dernière passe (la revue n'en aurait plus), ni quand le budget du lot ne paie plus la correction (la revue, elle, part toujours).
     const gate = c.config.testGate;
-    if (gate && !l.testGate && !minorsPass) {
+    if (gate && !l.testGate && !minorsPass && !l.express) {
         // Le diff du lot : son dépôt et ses dépôts voisins (comme hasWork), sans les fichiers que le lot supprime (du code mort supprimé n'a pas de test à écrire).
         const touched = new Set([
             ...filesOf(wd(c), lotWork(plan, wd(c), l.lot), { withoutDeleted: true }),
@@ -2341,6 +2341,9 @@ async function toReview(c, runs, minorsPass) {
         }
     }
     l.constats = [];
+    // Voie express (L519) : pas de revue séparée, le lead lit le diff ; le lot conclut sur le HEAD que la porte du programme vient de jouer.
+    if (l.express)
+        return conclude(c, expressSummary(git(wd(c), 'rev-parse', 'HEAD')));
     l.checks = runs.length ? { head: git(wd(c), 'rev-parse', 'HEAD'), tree: git(wd(c), 'rev-parse', 'HEAD^{tree}'), runs } : undefined;
     l.next = firstReview(c);
     save(c);

package/dist/orchestrate/depot.js

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

package/dist/orchestrate/express.js

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

package/dist/orchestrate/lock.js

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

package/dist/orchestrate/probe.js

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

package/dist/orchestrate/state.js

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

package/dist/plan-commit.js

@@ -29,6 +29,8 @@ export const PLAN_ACTIONS = {
     articleNoted: 'article à rafraîchir : titres livrés notés',
     /** `spec green` (L366) : jamais la liste des tests rescellés, elle va dans le corps du commit (header-max-length de commitlint). */
     specGreen: 'acceptation verte, vert: true posé par cadence spec green',
+    /** `cadence spec green` sur un lot déjà `vert: true` mais sans empreintes (L526). */
+    specGreenScelle: 'empreintes de l\'acceptation posées par cadence spec green',
     resealed: (norm) => `test d'acceptation rescellé (${norm})`,
     /** En minuscule : `subject-case` de config-conventional refuse une majuscule initiale (L343). */
     leadAnswer: (ids) => `${ids.length > 1 ? 'règles' : 'règle'} ${ids.join(', ')} ${ids.length > 1 ? 'sourcées' : 'sourcée'} par la réponse du lead`,

package/dist/plan.js

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

package/dist/repo-busy.js

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

package/docs/orchestrate.md

@@ -407,6 +407,7 @@ session, `accept` (L173): `precheck → spec → maquette → accept → impleme
   file, deletes it, creates one outside the accept step, or modifies a locked test hands the lot back (`verrou des tests d'acceptation : …`) — for a modified test the message ends with `; premier commit fautif : <sha7> <subject>`, the oldest commit after the reference (red commit, or the head before the lot) that touched the sealed path (a deletion or a rename included, renames not followed), and names no commit when the deviation is only in the working tree (L231) — a useful change is a question to the lead or a review finding, never a silent gesture. The lock does not depend on `orchestrate.accept` being declared. **Exception — a delivered lot (`vert: true`):** a later lot that makes the rule evolve may modify the listed tests of that acceptation when **a commit that cites the lot in progress amends the sheet of the screen and comes after the red commit** (a strict descendant of it; the commit may have been made before the wave, and once one exists the exception covers the whole acceptation: the tests may change in the same commit as the sheet, in a later one or in a following session, a `fix` after the `implement` for instance, L231): the sheet is what evolves the rules, and tests and sheet change together. A sheet amended by another lot, by a commit that cites no lot, by a commit that is not after the red commit, or only in the working tree (not committed) opens nothing. The exception never covers the acceptation of the lot in progress (its `vert: true` is set right after the implement): that one keeps the whole lock. Without a sheet change the difference is still a deviation — except one narrow case (L184): a listed file whose content is identical to what it was at the head before the lot's first **work** commit (commits found by the plan's refs) is not a deviation, the lot having taken its own addition back (a lot handed back for writing in a locked file and resumed in a new wave, which then removes that addition). This applies to every acceptation, `vert: false` included, but only to a file that **exists** at that head and now: a file absent at that head (e.g. created by the lot's own red commit) or deleted since is never exempted, so deleting a locked test stays a deviation; nor when the sheet of the screen has changed since that head (an evolution admitted for another lot: going back to the old content would cancel it, not the lot's addition); apart from that, with `vert: false` the whole lock applies, sheet change or not; `acceptation.json` itself stays locked (only its `vert` key moves).
 - **A sealed test that contradicts the sheet: `cadence spec reseal` (L200).** The lock is total for the lot in progress (the delivered-lot exception above never covers it; for a delivered lot, see the end of this item), so a test that is wrong against its sheet — e.g. the regex `/\d{1,2} /` of an acceptance test rejecting « T3 2027 annoncée », which the sheet allows — would leave the lot handed back with no way out. The way out is the lead's, outside any wave: correct the test in the working tree (the sheet is left as it is: unchanged since the red commit, or amended by commits of the lot and committed, see « A sheet amended in the same lot » below), then `cadence spec reseal <lot> <test> --reason "why the test contradicts the sheet"`. The program checks that the lot is in progress (`doing`; for a delivered lot, see the end of this item), that the test is listed in the lot's sealed `acceptation-<lot>.json`, that the sheet is unchanged since the red commit or amended by commits of the lot (below), that **no other listed test** changed (the lock keeps everything else) and that the test did change; it then redoes the fingerprint of that one test, appends `{ test, raison, date, avant, apres }` (plus `ficheAmendee` for an amended sheet, below) to the `resceaux` key of `acceptation.json`, commits the test and `acceptation.json` (`test(L35): acceptation rescellée, <test> : <reason>`, the new red commit) and the lot's note with the reason (`plan: …`). It is refused during an orchestrated wave (`CADENCE_ORCHESTRATED`, or the repository's wave lock while one of its lots still works, like `cadence deliver`), **while a wave that is not `done` (interrupted, suspended, or still alive with a lot waiting on a question) keeps open any lot of this repository that is still `doing` in this repository's plan (L238)** — the resealed lot, the `--porteur` or any other lot of the repository: the lock hands back every open lot of the repository, so a reseal committed in the meantime was handed back to any of them as the « first offending commit » of the lock (ol-companion L172, then L173). Open means any non-final state in the wave (a question waiting for its `--answer`, a lot suspended by the quota or the budget, a queued lot, a session running): a stopped wave holds no lock, but its `--resume` replays those lots. The filter is by repository (the repository of the lot's project, not its neighbour repositories: lot ids belong to each plan, so a finance-tracker L172 never blocks an ol-companion L172) and by plan: a lot that is `done` or absent in the plan never refuses, so an old interrupted wave whose lots are long delivered blocks nothing, and neither does a `done` wave. The error is a single message that names **every** wave concerned, with its launch folder and its open lots, the wave that holds the repository lock included (alive: while it has an open lot the lock refuses first, so the same message lists it together with the stopped waves of the repository, not the bare « orchestration en cours » line `cadence deliver` gives), and gives for each stopped wave ONE command, runnable as it stands, with a `--drop` per open lot of the repository in that wave, the queued ones that are not `doing` in the plan included (L239: `--resume` would relaunch them, and the lot would take the lock back and find the tree dirty with the corrected test): `cd <launch folder> && cadence orchestrate --resume --wave <wave> --drop <project>:<lot> --drop <project>:<lot>` (`--resume` replays the whole wave except the dropped lots, so one command per lot would start sessions on the others; it looks for the wave in the folder it is run from only); a wave that is still alive is not called suspended, the error says it is running and is to be waited for. A repository reached by another path (a worktree, a symbolic link) is the same repository: the `.git` directories are compared by their real path. The waves read are those of `.cadence/runs/` of the repository root, of the plan's folder and of every folder above them (a wave keeps its state where `cadence orchestrate` was launched, usually the parent folder of the projects), with no `--reason`, and on a lot that is neither in progress nor delivered with a green acceptation. Then, depending on how the lot stands: a lot waiting on a `question` sits in a wave that is not `done`, which refuses the reseal (L238): answer it first (`--resume --wave <wave> --answer`, the lot then goes on or is handed back) or close it (`--resume --wave <wave> --drop`), reseal afterwards if the lot is handed back (a rewrite of `acceptation.json` without a `resceaux` entry stays a violation of the lock); a lot handed back with `verrou des tests d'acceptation` is finished for `--resume`, so it is replayed by a new wave `cadence orchestrate <project>:<lot>`, which starts again from the red commit. A session never does it, three guards: (1) `cadence spec reseal` is in the sessions' `--disallowedTools` (like `raf done`/`review`/`ux`); (2) a resealed commit is adopted as the new red commit only if it belongs to **no session of the wave** (commits listed in each `steps[].commits`, or in `headBefore..headAfter` of any session of any lot of the wave) — otherwise it stays a violation of the lock; (3) the lock is checked at the end of **every** work session, a session that ends with a question included, so a session that replaces the test, forges the fingerprint, commits and asks a question is handed back with `verrou des tests d'acceptation` without waiting for the lead's `--answer`. The reseal is atomic: if the commit fails (a `pre-commit` hook exiting 1, say) `acceptation.json` and the test are put back as they were before the command (the lead's correction in the working tree is kept, nothing staged) and a readable error says nothing was resealed. With a plan kept read-only by another tool, the reseal itself succeeds but the plan is not touched: the note of the lot is left to the lead (the reason stays in `acceptation.json` and in the commit message; the command only says a note is to be added). With a plan outside the repository or untracked, the note **is** written in the plan file but not committed (the command says `plan à commiter`); do not add it a second time. If the commit of the note is refused (a hook), the reseal stays done: the error gives its commit and says the note, already written, is to be committed by hand. **A sheet amended in the same lot (L217):** a sheet amended since the red commit is accepted, for a lot in progress as for a delivered one (the sheet is then not put back to its red state to be restored afterwards). When its net difference with the red commit (`git diff <red> -- <sheet>`) is not empty, the command reads `git log <red>..HEAD -- <sheet>`: every commit that touched it must cite the lot (read like `raf commits`, i.e. `citedRefs`: the scope of the subject first, the body otherwise; for a delivered lot, the lot, the `--porteur` or any delivered lot of the plan, status `done`, L229: the living sheet is the reference; one cited delivered lot among several is enough), and the sheet must be committed. The fingerprint of the test is then redone against the current sheet and the `resceaux` entry gains the optional key `ficheAmendee` (short sha of the last commit that touched the sheet); the lot's note and the commit message say `fiche amendée en <sha>` instead of `fiche inchangée`. Still refused, with nothing written: a sheet modified by a commit that cites neither the lot nor (delivered lot) the `--porteur` or a delivered lot (`la fiche … a été modifiée depuis le commit rouge … par un commit qui ne cite pas <lot> : <sha>`; for a delivered lot `… ne cite ni <lot>, ni le porteur <porteur>, ni un lot livré : <sha> (cite : <lots ou aucun lot>) — faire citer le porteur ou un lot livré par ce commit (le réécrire avant qu'il soit poussé) ou, sinon, rescelle à la main avec le lead`), a sheet deleted or renamed since the red commit, a sheet with uncommitted changes (working tree or index: `a des modifications non commitées : la commiter (en citant <lot>) avant le rescellé`), as before any other listed test touched, a test left unchanged, an orchestrated wave and a missing `--reason`; the atomicity is unchanged. A sheet amended then brought back to the identical content is treated as unchanged, whoever committed in between. After the reseal the new red commit is the reseal commit, so a second reseal sees the sheet as unchanged. **A delivered lot (L212):** a lot whose acceptation is green (`vert: true`) and whose sealed test turns out unstable while the contract does not change (seen: a tab read as « blank » in CI) had no way out but the « sheet modified in the same lot » exception. `cadence spec reseal <lot> <test> --reason "why" --porteur <lot in progress>` now covers it, with the same guards (the sheet unchanged since the red commit, or amended as above by commits that cite the delivered lot, the carrier or another delivered lot; no other listed test touched, no wave, `--reason`) and three differences: `--porteur` is required and names the lot in progress that carries the fix (refused if it is the delivered lot itself, unknown or not `doing`); the commit cites the **carrier** (`test(L113): acceptation rescellée du lot livré L47, <test> : <reason>`) and so does the plan note and its commit, the delivered lot being closed; the dated `resceaux` entry also records `porteur`, and `vert` stays `true`. `--porteur` on a lot in progress, or `spec reseal` on a delivered lot without `--porteur`, is refused.
 - **A closed lot left at `vert: false`: `cadence spec green` (L366).** The cycle sets `vert: true` itself; a lot driven and closed by hand (`raf done`) never gets it, and its `acceptation-<lot>.json` then keeps the lock total on its tests: every later wave of the repository is handed back with `verrou des tests d'acceptation … premier commit fautif` on lots that never touched them. Three guards:
+  - A lot already at `vert: true` but with no fingerprint for one of its listed tests (closed before the seal, L526, issue #20) is not « already green »: `cadence spec green <lot>` replays the command and, green, seals the missing fingerprints (the others are kept, no `resceaux` entry) in a commit of the file alone citing the lot (`chore(L12): empreintes de l'acceptation posées par cadence spec green`, or the `plan.commit` template); red: nothing changes, exit 1. A lot green and fully sealed still prints « déjà vert » and runs nothing.
   - `cadence spec green <lot>` runs the dedicated command (`orchestrate.accept`, same rules as the cycle: the commands whose root holds a listed file, `{acceptation}` and `CADENCE_ACCEPTATION` set; a listed file under no command's root is refused) and, when it is green, sets `vert: true` and commits the file alone, citing the lot (`chore(L12): acceptation verte, vert: true posé par cadence spec green`, or the `plan.commit` template of the project when it has one). The subject stays short and fixed: the resealed tests are listed in the commit body, one `- <path>` line each, so a `commit-msg` hook bounding the header (commitlint `header-max-length` 100) accepts the commit. Tests refined by the lot after the red commit (the case of issue #18: its own fix commits changed them) would still be reported by the lock, whose reference is the red commit: the command therefore reseals every listed test whose fingerprint changed (the `empreintes` are redone, one `resceaux` entry each) in that same commit, which becomes the red commit; a listed test changed but not committed is refused before anything runs. Red: the tail of the output on stderr, exit 1, nothing changed. Already green: nothing to do. Refused for a `todo` lot, with `CADENCE_ORCHESTRATED` set, while a wave holds the repository lock and while an unfinished wave keeps a lot of the repository open (the same refusals as `spec reseal`, worded for `spec green`: « spec green : refusé … puis relancer spec green »).
   - `raf done <lot>` refuses a lot whose acceptance is `vert: false` (the message names the file and the command above); `--force` closes it anyway and warns on stderr.
   - `cadence orchestrate … --dry-run` prints once per repository `⚠ <repo> · acceptation rouge d'un lot clos : L12 (<file>, vert: false)` for each `done` lot left that way, before the wave starts.
@@ -558,6 +559,17 @@ except a copy that is still needed, which stays and is said: a copy that a live
 The waves that count are those of the launch folders the script knows (`<folder>/.cadence/runs/<wave>/wave.json`): the repository itself and the working directory of every wave the orchestrator's registry still lists (`~/.cadence/orchestrate/waves/<pid>.json`; the registry drops a dead wave when another registers, so it does not know suspended waves by itself). There is no search over the whole disk: a suspended wave launched from another folder is not protected here, and `--resume` repairs its snapshot instead (above). A wave never marked `done` keeps its copy until it is, or until its folder is removed. A failure of the purge (unreadable copy, busy file) once `service` and the links have switched is a warning on the error output (`avertissement : purge des anciennes copies interrompue …`): the new version is in service, the fingerprint is printed, the exit code is 0, the next put in service tries again. The same run updates the **local copy of the `cadence-hud` mod** (L419), the one `CLAUDE_CODE_PLUGIN_DIRS` makes Claude Code load (`~/.claude/mods/cadence-hud`, `--mod-dir` for another folder): `plugins/cadence-hud` of the copy just put in service (not the working repository) is synchronised into it with `rsync -a --delete`, which leaves out `.claude-plugin/types` (generated by Claude Code in the copy). The output says `mod cadence-hud : copie locale mise à jour (<dir>)`. A machine without that folder gets no copy created (`copie locale absente … non mise à jour`), and a failed `rsync` is a warning on the error output (`avertissement : mod cadence-hud non mis à jour …`), exit code 0 like the purge: the version is in service. Before L419 the copy was updated by hand at each release and a forgotten one left the old mod loaded. The first run is also what installs the links in `~/.local/bin`. It prints the fingerprint of the copy
 (bin, dist, package.json).
 
+## Express lane (L519)
+
+A lot of **at most 0.1 day** (`estimate: 0.1` or less, no `screen:`, no `spec: true`) takes the express lane, with no key to set. The L517 study ([docs/mesures/temps-d-un-lot.md](mesures/temps-d-un-lot.md), lever 2) measures 15.5 min and 116 k counted tokens for such a lot, 44 % of them in review and preparation: the lane cuts about 4.9 min and 51 k tokens per lot. What changes:
+
+- **One writing session.** No precheck (even on the local model), no edge-case probe (`orchestrate.probe` is ignored for the lot), no separate code review and no UX review: the lead reads the diff and looks at the capture. After the program's gate the lot is `ready`, with the verdict `conforme : voie express …` recorded in the plan at the sha of its last commit (so `raf done` and the review gate accept it).
+- **The full gate plays once** (`orchestrate.build`, then `orchestrate.test`, as for any lot): a red test still sends the lot to a correction pass. Only the « code sans test » gate (`orchestrate.testGate`) is off, because a purely visual change has no new test to write; the `implement` brief says so (« Express lane »: a change of behaviour still gets its test first).
+- **No News entry per lot.** The brief of a visible express lot asks for a capture and no `cadence news new`; the lead groups the entries at delivery. `raf check` still wants an entry for a visible lot, so write the grouped entry before `raf done`.
+- `--dry-run` prints `voie express` and the single step `implement`.
+
+A lot above 0.1 day, or with a screen or a spec sheet, keeps the full cycle. The threshold is `EXPRESS_MAX_ESTIMATE` in `src/orchestrate/express.ts`.
+
 ## The edge-case probe (`orchestrate.probe`, L497)
 
 Code bugs are the first cause of correction passes, and an edge case is the first sub-cause of those (64 % of the `bug-code` passes since the instruction of L447, 69 % before: writing it in the brief changed nothing). `orchestrate.probe: true` adds a step between the writing and the review: a **fresh Sonnet session** (`probe`, brief `templates/orchestrate/probe.md`, `effort.probe` medium, the delay of a write step `timeouts.work`) that has not written the code, reads the lot's diff, and tries to break it with tests at the edges: empty, absent, twice, wrong type, refused, the real shape of the data, the other callers. The diff is given as a command (`git diff <start sha>..HEAD`), never pasted; the sheet of the lot is named when there is one. Like `implement` and `fix`, the brief gives the program's exact gate (L399: the probe commits tests the gate replays, `tsc` and the quality script included) and the session's machine share (L350). The session writes its tests in new files and commits them all, the passing and the failing, with `probe(L<n>): …`; it does not touch the application code nor the sealed acceptance tests.

package/docs/raf.md

@@ -52,7 +52,7 @@ raf gantt                         # .cadence/gantt.html (next to the plan)
 |---|---|
 | `raf --version` · `raf -v` | print the version of the package, as `cadence --version` does (L376); only as the first argument, `raf show --version` stays an unknown option |
 | `raf init [--project name] [--prefix L] [--no-hook]` | create the plan, install the hook, add `.playwright-mcp/` to `.gitignore` |
-| `raf add "title" [--estimate d] [--quickwin] [--visible [--screen page\|component\|journey]] [--spec] [--public "title"] [--after L2,L4] [--uses banc,passerelle] [--parent L3]` | add a lot or a sub-task, print its id (`--public`: the lot's title in the public's words, written as `public:` right after `title:`; `--screen`: the screen a visible lot creates or changes — a new `page`, a new `component` or a modified `journey` — written as `screen:` right after `visible:`, shown by `raf show`; it requires `--visible`, and `raf check` reports a `screen:` without `visible:` or with another value as an error. Only `page` triggers the spec step of `orchestrate` (L209), never inferred from the title; `--spec`: the lot changes a behaviour (something a user, an API client or another service can observe), written as `spec: true` right after `screen:`, `visible:`, `quickwin:` or `estimate:` (whichever comes last), shown by `raf show`, refused on a sub-task. Also set by the lead at planning time, never inferred from the title); `--uses`: the shared resources the lot occupies, written as `uses: [banc, passerelle]` after `after:` and before `created:` ([shared resources](#shared-resources-uses-and-resources), L251), refused on a sub-task) |
+| `raf add "title" [--estimate d] [--quickwin] [--visible [--screen page\|component\|journey]] [--spec] [--local] [--public "title"] [--after L2,L4] [--uses banc,passerelle] [--parent L3]` | add a lot or a sub-task, print its id (`--public`: the lot's title in the public's words, written as `public:` right after `title:`; `--screen`: the screen a visible lot creates or changes — a new `page`, a new `component` or a modified `journey` — written as `screen:` right after `visible:`, shown by `raf show`; it requires `--visible`, and `raf check` reports a `screen:` without `visible:` or with another value as an error. Only `page` triggers the spec step of `orchestrate` (L209), never inferred from the title; `--spec`: the lot changes a behaviour (something a user, an API client or another service can observe), written as `spec: true` right after `screen:`, `visible:`, `quickwin:` or `estimate:` (whichever comes last), shown by `raf show`, refused on a sub-task. Also set by the lead at planning time, never inferred from the title); `--local`: the lead edits this repository by hand for this lot, written as `local: true` right after `spec:` (or the last key before it), refused on a sub-task ([a lot of the lead](#a-lot-of-the-lead-local-l519)); `--uses`: the shared resources the lot occupies, written as `uses: [banc, passerelle]` after `after:` and before `created:` ([shared resources](#shared-resources-uses-and-resources), L251), refused on a sub-task) |
 | `raf add "title" --every <days>` · `raf did <id> ["text"]` | recurring lot: `every` (days) and `last` (last time done) fields; the lot stays `todo`, `raf now` and `session start` list it under « Récurrent » with « dû depuis N j » / « prochain dans N j »; `raf did` resets the count (spec: `docs/superpowers/specs/2026-10-04-L11-tache-recurrente.md`) |
 | `raf screen <id> page\|component\|journey\|none` | set, replace or remove `screen:` on an existing lot, to adopt the [spec step](orchestrate.md#the-spec-step-of-a-lot-with-screen) on a plan already written (only `page` adopts the [spec step](orchestrate.md#the-spec-step-of-a-lot-with-screen); `component` and `journey` do not); refused on a lot without `visible:` (like `raf add --screen`) and on a sub-task; `none` removes the key and leaves `visible:` alone |
 | `raf visible <id> on\|off` | set or remove `visible:` on an existing lot (a user-facing change: a news entry is expected, and `cadence orchestrate` adds its UX step), written right after `quickwin:`, `estimate:` or `status:` (whichever comes last); `on` on a visible lot changes nothing, `off` on a lot without the key neither; refused on a sub-task, and `off` is refused while the lot has a `screen:` (`raf screen <id> none` first: a screen is a visible change). It is the fix `raf check` points to for an open « Revue UX — » lot without `visible:` (L273) |
@@ -63,7 +63,7 @@ raf gantt                         # .cadence/gantt.html (next to the plan)
 | `raf add`, `raf note`, `raf done` while a wave works in the main tree (L475) | when the repository's orchestration lock is held by a live wave and one of its lots is in `implementing`, `reviewing` or `fixing` **without a worktree** (a wave without worktrees, or a lot whose worktree folder does not exist), these commands write the plan as usual and print on stderr `avertissement : la vague … travaille dans l'arbre principal de ce dépôt (projet:lot) — …`: a plan commit of the lead then hands the lot back at review (2026-10-30: cadence L458 handed back by a plan commit during its review). Write the plan without committing it, or commit once the step ends. Exit code 0; nothing is printed for lots that are queued, in question, ready, handed back, failed or suspended, for lots playing in their worktree, from a worktree of the repository, from a session of the wave itself (`CADENCE_ORCHESTRATED` set), when the lock belongs to a dead process, or when the wave's state is unreadable |
 | `raf public <id> "title"` · `raf public <id> --clear` | set, replace or remove the public title of a lot |
 | `raf start <id>` · `raf done <id> [--force]` · `raf drop <id> [--reason text]` | dated transitions (`done` refuses open sub-tasks unless `--force`, with the code-review gate active (`raf review enable`) a lot whose commits its review does not cover, **and a lot whose recorded review verdict says `non conforme` / `not compliant` even when it covers every commit** (L476: `non conforme : 1 bloquant` at the last commit no longer closes; `conforme après 1 correction` is compliant; redo the review with `raf review <id> "verdict"` after the fix, or `--force`), and a lot whose `acceptation-<lot>.json` is still `vert: false`, L366: closed like that it would lock every later wave of the repository, see `cadence spec green`; with `--force` it only warns on stderr. Like every `raf` command it only writes the plan file and **never commits** it: when the plan or a file `plan.onWrite` produces is left with changes, `done`, `ux <lot>` and `review <lot>` print the `git add` / `git commit` command that takes them, the subject from the `plan.commit` template, L371) |
-| `cadence spec green <lot>` | L366: run the dedicated acceptance command (`orchestrate.accept`) on a lot driven or closed by hand; green, set `vert: true` in its `acceptation-<lot>.json` and commit that file alone (subject `chore(<lot>): acceptation verte, vert: true posé par cadence spec green` or the `plan.commit` template; the resealed tests are listed in the commit body, never in the subject), resealing the fingerprints of the listed tests refined since the red commit (journal `resceaux`) so the lock goes quiet; a listed test changed but not committed is refused. Red: exit 1, nothing changed. Refused for a `todo` lot, during a wave, and while an unfinished wave keeps a lot of the repository open; see [orchestrate](orchestrate.md) |
+| `cadence spec green <lot>` | L366: run the dedicated acceptance command (`orchestrate.accept`) on a lot driven or closed by hand; green, set `vert: true` in its `acceptation-<lot>.json` and commit that file alone (subject `chore(<lot>): acceptation verte, vert: true posé par cadence spec green` or the `plan.commit` template; the resealed tests are listed in the commit body, never in the subject), resealing the fingerprints of the listed tests refined since the red commit (journal `resceaux`) so the lock goes quiet; a listed test changed but not committed is refused. Red: exit 1, nothing changed. A lot already `vert: true` whose tests lack fingerprints (L526) is replayed and, green, sealed (subject `chore(<lot>): empreintes de l'acceptation posées par cadence spec green`). Refused for a `todo` lot, during a wave, and while an unfinished wave keeps a lot of the repository open; see [orchestrate](orchestrate.md) |
 | `raf todo <id> [--reason text]` | put a started lot back to `todo` (`doing` → `todo`, `started:` removed, dated note « remis en attente : reason »): refused when work commits cite the lot (plan-only and version commits do not count, as `raf commits`), or on a sub-task; sub-tasks and other keys are left as they are. **Reopening** (L396): on a `done` or `dropped` lot, `raf todo` is THE command — never the YAML — that reopens it (`→ todo`, `finished:` removed, `started:` kept so its commits stay its own, dated note « rouvert (était done) : reason »); `raf start`/`raf done`/`raf drop` on a closed lot say so (`L3 est done ; le rouvrir si c'est voulu : raf todo L3`). An archived lot reopened this way comes back into the plan file at that write |
 | `raf migrate [--dry-run]` | move `docs/plan/raf.yaml` to `.cadence/raf.yaml` and rewrite the readers of the old path in the repository, see [Moving the plan: `raf migrate`](#moving-the-plan-raf-migrate) |
 | `raf note <id> "text"` | dated note — keep decisions next to the work |
@@ -108,6 +108,18 @@ pre-commit block to an existing repository. A read-only plan is never started by
 Global options: `--file path` or `RAF_FILE`; `RAF_TODAY=YYYY-MM-DD` to freeze
 the date. `cadence raf …` is the same as `raf …`.
 
+## A lot of the lead (local, L519)
+
+`raf add "…" --local` marks a lot (`local: true`) that the lead does by hand in this repository instead of giving it to a wave (a touch-up the lead would rather see in the editor, a change that needs the lead's eyes all along). Two commands carry it:
+
+| Command | What it does |
+|---|---|
+| `cadence local start <lot> [--ttl minutes]` | locks the repository as a wave does (`orchestrate.lock`, under the name `local:<lot>`): no wave starts in it, `orchestrate --resume` and `orchestrate --add` are refused with « une tâche locale du lead y est en cours (<lot>, depuis …) », and `deliver` and `raf move` are refused with the same message (the task is named with its exit `local done` / `local abort`; no `--sha` advice, a local task has no wave lots). The lot goes to `doing`. The lock is **declared**, like `cadence lead hold`: no process carries it (the shell that runs the command dies with the Bash tool call, and the lead's session has no stable process name), it holds until `local done` or `local abort`, and `--ttl` (60 min by default) is only the announced duration — past it, the lock still holds and `cadence lead tour` and `orchestrate --status` print « ⚠ tâche locale échue : <lot> … » until the lead finishes or aborts it; it never lapses silently. Refused, with nothing locked or written, when the lot is unknown, not marked `local`, `done` or `dropped`, when a wave or another local task holds the repository, or when another lot of the plan is `doing` (it is named). |
+| `cadence local done <lot>` | plays the project's gate **once** (`orchestrate.build`, then `orchestrate.test`, at `HEAD`, as `cadence verify --gate`) and, if it is green, frees the repository. Red (code 1) or nothing to replay (code 2): the lock stays, fix and run it again. Refused when this lot's local task does not hold the lock. |
+| `cadence local abort <lot>` | frees the repository without playing the gate (the task is given up or will be resumed later); the plan is not touched — the lot stays `doing`, `raf todo <lot>` puts it back. Refused when this lot's local task does not hold the lock. |
+
+`local start` writes the plan (the lot goes to `doing`): commit it with the first commit of the lot. After `local done`: take the capture of a visible lot, read the lot's diff and record the verdict yourself (`raf review <lot> "…"` — on a plan with `reviewSince`, `raf done` refuses a lot with commits and no verdict; the express lane records its own verdict because a session did the work and the lead reads the diff at delivery, here the lead did the work, so the verdict is the lead's own reading and is written by hand), `cadence deliver`, then `raf done <lot>` — the lot is traced in the plan like any other (its commits cite it, `feat(L12): …`). A local lot is never played by a wave: `cadence orchestrate <project>:<lot>` (launch, `--add`, `--continue`) refuses it by name. During the task the pre-push hook sees the lock as a local task, not as a wave: no wave check, no « état illisible » warning; the gate check (`CADENCE_PUSH_UNGATED`) applies as usual.
+
 ## Shared resources: `uses:` and `resources:`
 
 Some projects of a folder share one thing that only one lot at a time can use (a test bench, a gateway, a

package/docs/spec.md

@@ -28,7 +28,7 @@
 
 `cadence spec reseal <lot> <test> --reason texte` is the lead's way to correct one sealed acceptance test of the lot in progress that contradicts its sheet (unchanged, or amended by commits of the lot, L217; of a delivered lot, also by commits of another delivered lot, L229) (of a delivered lot: add `--porteur <lot in progress>`); refused while a wave of the repository is running, or a wave that is not `done` keeps open (question waiting, suspended, queued) any lot of this repository still `doing` in its plan, the resealed lot or another (L238: one error, also when a live wave holds the lock, names each wave (live ones to wait for), its launch folder and, for each stopped wave, the single `cd <folder> && cadence orchestrate --resume --wave <wave> --drop <project>:<lot> --drop …` that closes all its open lots of the repository, the queued ones that are not `doing` in the plan included (L239); a lot `done` or absent in the plan never refuses), see [The accept step](orchestrate.md#the-accept-step-red-acceptance-tests-and-their-lock).
 
-`cadence spec green <lot>` (L366, GitHub issue #18) is the lead's way to put back to green a lot driven and closed by hand (`raf done`) whose `acceptation-<lot>.json` stayed at `vert: false`: closed like that, its tests keep the lock total and every later wave of the repository is handed back with `verrou des tests d'acceptation … premier commit fautif` on lots that never touched them, and `spec reseal` does not cover it (it takes a lot `doing`, or a delivered lot at `vert: true` with `--porteur`). The program runs the lot's acceptance command (`orchestrate.accept`, same rules as the cycle) and, green, sets `vert: true`, reseals the listed tests refined since the red commit (one `resceaux` entry each) and commits the file alone, citing the lot (`chore(<lot>): acceptation verte, vert: true posé par cadence spec green`, or the project's `plan.commit` template when it has one; the subject stays short and fixed, the tests resealed are listed in the commit body, one `- <path>` line each, so a `header-max-length` hook accepts it); red, the tail of the output goes to stderr, exit 1, nothing changed; already green, nothing to do. Refused for a `todo` lot, from a session (`CADENCE_ORCHESTRATED`), during a wave of the repository and while an unfinished wave keeps a lot of the repository open (the same refusals as `spec reseal`, worded for `spec green`); a listed test changed but not committed is refused before anything runs. `raf done` refuses such a lot without `--force`, and `cadence orchestrate --dry-run` prints `acceptation rouge d'un lot clos` once per repository, see [A closed lot left at vert: false](orchestrate.md#the-accept-step-red-acceptance-tests-and-their-lock).
+`cadence spec green <lot>` (L366, GitHub issue #18) is the lead's way to put back to green a lot driven and closed by hand (`raf done`) whose `acceptation-<lot>.json` stayed at `vert: false`: closed like that, its tests keep the lock total and every later wave of the repository is handed back with `verrou des tests d'acceptation … premier commit fautif` on lots that never touched them, and `spec reseal` does not cover it (it takes a lot `doing`, or a delivered lot at `vert: true` with `--porteur`). The program runs the lot's acceptance command (`orchestrate.accept`, same rules as the cycle) and, green, sets `vert: true`, reseals the listed tests refined since the red commit (one `resceaux` entry each) and commits the file alone, citing the lot (`chore(<lot>): acceptation verte, vert: true posé par cadence spec green`, or the project's `plan.commit` template when it has one; the subject stays short and fixed, the tests resealed are listed in the commit body, one `- <path>` line each, so a `header-max-length` hook accepts it); red, the tail of the output goes to stderr, exit 1, nothing changed; already green and sealed, nothing to do; already `vert: true` but with a listed test lacking its fingerprint (closed before the seal, L526, issue #20), the command is replayed too and, green, only the missing fingerprints are sealed in a commit citing the lot (`chore(<lot>): empreintes de l'acceptation posées par cadence spec green`), red nothing changes. Refused for a `todo` lot, from a session (`CADENCE_ORCHESTRATED`), during a wave of the repository and while an unfinished wave keeps a lot of the repository open (the same refusals as `spec reseal`, worded for `spec green`); a listed test changed but not committed is refused before anything runs. `raf done` refuses such a lot without `--force`, and `cadence orchestrate --dry-run` prints `acceptation rouge d'un lot clos` once per repository, see [A closed lot left at vert: false](orchestrate.md#the-accept-step-red-acceptance-tests-and-their-lock).
 
 `cadence spec qa <fiche.yaml>` derives from a valid sheet the section of `docs/qa/expectations.md` for its screen and prints it on the standard output
 (it never writes the file: you paste the section, and the lead commits it like the rest of the plan files). A sheet with violations prints them on the

package/docs/whats-new.md

@@ -4,6 +4,8 @@
 
 ## In two lines
 
+- **1.38.1**: `spec green` seals a lot closed at `vert: true` without fingerprints (issue #20); `deliver`, `raf move`, `spec reseal` and `spec green` refuse cleanly during a local task.
+- **1.38.0**: an express lane plays a touch-up of at most 0.1 day in one session; `raf add --local` and `cadence local start|done|abort` lock a repository while the lead edits it by hand.
 - **1.37.0**: one full test suite per lot, played by the gate (`suites` column); no correction pass without a finding; a richer implementation brief; `scripts/temps-d-un-lot.mjs` measures where a lot's time goes.
 - **1.36.0**: `cadence deliver` no longer waits for the CI of a sha whose commits only touch the plan, with timed steps and a `deliveries-steps.log` journal; `orchestrate --add` puts a lot in a live wave.
 - **1.35.0**: a test already red before a lot, or that only needs more time, no longer costs correction passes, including on a gate declared in parts; QA passes run in browsers of their own; design agents check contrast and AI tics.
@@ -65,7 +67,11 @@ Each is a paragraph in [docs/whats-new.md](whats-new.md) and a full section in [
 
 The long form of « In two lines » above (the README no longer carries a « What's new » section since L326: it links here). The full history, with the date of each version, is in [CHANGELOG.md](../CHANGELOG.md).
 
-**1.37.0**: the first release of the efficiency work, sized by a measure of 721 lots (L517, `docs/mesures/temps-d-un-lot.md`, script `node scripts/temps-d-un-lot.mjs`): a lot took 25 minutes and 265k tokens, tests were 62 % of the writing sessions' wall time and a correction pass cost about 12 minutes. The writing sessions of `cadence orchestrate` now play only the targeted tests of the code they touch; the full suite is played once by the program as the gate, `cadence verify --gate` takes its verdict back, and the final table and `--status` count the full suites of each lot in a `suites` column (L518, `docs/orchestrate.md`). A non-compliant review that lists no blocking or major finding no longer opens a correction pass: the lot is handed back with the announced totals as the cause; a test red in the suite and green alone is proposed as a lot to stabilise, and a green program gate always outweighs a session's claim of red tests (L522). The `implement` brief carries the code reviewer's grid, « edge-case tests first, seen failing, then code » and a re-reading of the diff before the last commit; the pre-check passes what it read (`precheckLu`) to the first implementation so it does not read the repository again (L523). The tests workflow tolerates the npm « previously published » refusal of its publish dry-run on a non-release commit, and nothing else (L515). `raf --version` and `raf -v` print the version, and `cadence orchestrate alpha:L1` launched from inside `alpha` says why the folder is not found (L376).
+**1.38.1**: `cadence spec green <lot>` now handles a lot closed at `vert: true` with no fingerprints (closed before the seal, GitHub issue #20): it replays the lot's acceptance command and, green, writes the fingerprints in a commit that cites the lot, so a later lot that amends one of its tests no longer has to be finished outside a wave (L526, `docs/orchestrate.md`). During a local task of the lead (1.38.0), `cadence deliver`, `raf move`, `cadence spec reseal` and `cadence spec green` refuse with a message that names the task and how to end it, instead of « état illisible » or an impossible `--sha` hint (L525, `docs/raf.md`).
+
+**1.38.0**: two ways to make a small change cheaper (L519, decided on 01-11 after a one-line UI separator cost 245 s of implementation). The **express lane**: a lot of at most 0.1 day with no screen sheet nor spec is played by `cadence orchestrate` in a single writing session, without precheck, edge-case probe, separate code review or « code sans test » gate, and without a News entry per lot; the lead reads the diff and the capture, groups the entries at delivery, and the program's gate still plays once (`docs/orchestrate.md`). The **local task**: `raf add --local` marks a lot the lead does by hand, and `cadence local start <lot>` locks the repository like a wave (no wave starts there, `--add` and `--continue` refuse it, and the task itself is refused while a wave or another lot of the repository runs). The lock is declared with a `--ttl` (60 min by default, like `lead hold`) and carried by no process; past its TTL it still holds and `lead tour` and `orchestrate --status` show a ⚠ until `cadence local done` (gate green) or `cadence local abort`. A wave refuses a `local` lot, and the pre-push hook recognises the task instead of reporting an unreadable wave (`docs/raf.md`).
+
+**1.37.0**: the first release of the efficiency work, sized by a measure of 721 lots (L517, `docs/mesures/temps-d-un-lot.md`, script `node scripts/temps-d-un-lot.mjs`): a lot took 25 minutes and 265k tokens, tests were 62 % of the writing sessions' wall time and a correction pass cost about 12 minutes. The writing sessions of `cadence orchestrate` now play only the targeted tests of the code they touch; the full suite is played once by the program as the gate, `cadence verify --gate` takes its verdict back, and the final table and `--status` count the full suites of each lot in a `suites` column (L518, `docs/orchestrate.md`). A non-compliant review that lists no blocking or major finding no longer opens a correction pass: the lot is handed back with the announced totals as the cause; a test red in the suite and green alone is proposed as a lot to stabilise, and a green program gate always outweighs a session's claim of red tests (L522). The `implement` brief carries the code reviewer's grid, « edge-case tests first, seen failing, then code » and a re-reading of the diff before the last commit; the pre-check passes what it read (`precheckLu`) to the first implementation so it does not read the repository again (L523). The tests workflow tolerates the npm « previously published » refusal of its publish dry-run on a non-release commit, and nothing else (L515).
 
 **1.36.0**: `cadence deliver` stops waiting for a CI that proves nothing. When every commit since the previous delivery touches only the plan, it says `→ CI : non attendue (aucun fichier hors plan depuis <sha>)`, then runs the deploy and the checks; as soon as one commit touches anything else, or the proof is missing (no previous delivery, rewritten history, no plan, empty range), it waits as before (L516, `docs/deliver.md`). 42 % of the app deliveries measured on 2026-11-01 were such shas. Every step line of the output now starts with its UTC time and `✓ livré` ends with its duration, and each step played appends a JSON line to `deliveries-steps.log`, so a slow delivery can be read step by step. `cadence orchestrate --add <project:lot> [--wave <wave>]` adds a lot to a live wave instead of launching a second one: the lot is checked like a launched one, queued in the wave's `adds.log` and played as soon as a session slot is free; the refusal of a second wave in the same repository now names this command, with the lot and the wave (L421, `docs/orchestrate.md`). A session running in a sibling repository is no longer handed back for a commit on another repository's main branch once a lot was added to the wave.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylad/cadence",
-  "version": "1.37.0",
+  "version": "1.38.1",
   "description": "A small, repo-native working method: a versioned plan linked to your commits, a changelog with screenshots, session rituals and deliveries proven by their effect.",
   "license": "MIT",
   "author": "Sylvain Ladoire",

package/templates/orchestrate/implement.md

@@ -4,6 +4,7 @@ Goal: {{objectif}}
 {{repos}}
 {{fiche}}
 {{decisions}}
+{{express}}
 Rules: test first; commit each sub-part as soon as its tests pass, with explicit paths (never
 `git add -A` or `commit -a`), and a message that cites the lot (`feat({{lot}}): …`); run the targeted tests of the code you touch (once, before committing) and the build, before reporting: the full suite is played once by the program as the gate given below, do not replay it (with no gate below, play the full suite yourself, once); do not push, deliver, run `raf done`, `raf ux` or
 `raf review`.