@sylad/cadence 1.36.0 → 1.38.0

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

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

package/README.md

@@ -47,14 +47,14 @@ 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.
 - [docs/ref.md](docs/ref.md): reference documents (specs, norms, mock-ups) and the coverage of their elements by the lots.
 - [docs/lead.md](docs/lead.md): the lead workflow, and the `livreur` agent that delivers a ready lot for it.
-- [docs/overview.md](docs/overview.md): the longer introduction and the map of every page.
-- [docs/fonctionnement.md](docs/fonctionnement.md): how it all works, in four figures.
+- [docs/overview.md](docs/overview.md): the longer introduction and the map of every page; [docs/fonctionnement.md](docs/fonctionnement.md): how it works.
 - [docs/stabilite.md](docs/stabilite.md): what is guaranteed from 1.0.0; [docs/qualite.md](docs/qualite.md): the code-quality ratchet.
 - [docs/whats-new.md](docs/whats-new.md) and [CHANGELOG.md](CHANGELOG.md): what changed.
 

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,12 +24,10 @@ 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';
@@ -41,19 +39,21 @@ 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);
@@ -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
@@ -1469,6 +1432,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/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/\`.`;
@@ -82,6 +91,23 @@ export function localReading(lot) {
         'Keep every read small (`grep -n`, `git log --oneline -S`, a few dozen lines at a time, never a whole large file),',
     ].join('\n');
 }
+/**
+ * Ce que le précheck apporte au brief de l'implémentation : son constat (« partiel ») puis, séparée par une ligne vide, ce qu'il a lu
+ * (L523), pour que la session parte de là au lieu de tout relire à froid. `lu` n'est passé qu'à la première passe : la lecture date du
+ * début du lot, une reprise après interruption a des commits à relire (l'appelant ne le passe pas). Sans constat ni lecture, `commits` est rendu tel quel.
+ */
+export function precheckBrief(commits, finding, lu) {
+    const withFinding = finding ? [commits, finding].filter(Boolean).join('\n') : commits;
+    if (!lu)
+        return withFinding;
+    const reading = [
+        'Pre-check reading (L523): the read-only pre-check of this lot, at the start of the lot, looked in the repository and read this.',
+        'Start from these files, the neighbouring code to imitate and the existing tests it names, without searching for them again;',
+        'reopen a file only to modify it or when this reading is not enough, and re-read the lines you edit (the reading dates from the start of the lot).',
+        lu,
+    ].join('\n');
+    return [withFinding, reading].filter(Boolean).join('\n\n');
+}
 const FILES = {
     precheck: 'precheck.md',
     spec: 'spec.md',
@@ -100,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 = {};
@@ -120,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;
@@ -129,9 +157,9 @@ export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
     return `${out.replace(/[ \t]+\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim()}\n`;
 }
 /**
- * Consigne `{{gate}}` (L399) : le programme rejoue après chaque écriture `orchestrate.test` et `orchestrate.build`, pas la commande que la session juge équivalente.
+ * Consigne `{{gate}}` (L399, L518) : le programme joue une fois après l'écriture `orchestrate.test` et `orchestrate.build` ; la session ne joue que les tests ciblés du code touché (la suite entière rejouée en session coûtait 2,7 suites par lot, étude L517) et le build tel quel, pas la commande qu'elle juge équivalente.
  * Du 22 au 28-10, des lots annoncés verts arrivaient rouges à la porte parce que la session avait joué `npm run build` (tsconfig.build.json : `src` seul)
- * alors que la porte joue `npx tsc --noEmit` (test et scripts compris) : L330, L353. Vide sans commande déclarée.
+ * alors que la porte joue `npx tsc --noEmit` (test et scripts compris) : L330, L353. Vide sans commande déclarée ; sans `orchestrate.test`, la session joue elle-même la suite complète, une fois.
  */
 export function gateText(gate) {
     // Porte en parties (L512) : une ligne par partie, avec son dossier, jamais la liste sérialisée.
@@ -139,7 +167,10 @@ export function gateText(gate) {
     const lines = [...tests, gate.build ? `- build: \`${gate.build}\`` : ''].filter(Boolean);
     if (!lines.length)
         return '';
-    return `The program's gate, played after every writing session, is exactly:\n${lines.join('\n')}\nRun these commands as written before reporting, not a narrower one (\`npm run build\` or \`npm test\` may cover less than the gate). A red there sends the lot back to a correction pass even when your own run was green.`;
+    // Sans `orchestrate.test`, le programme ne joue aucune suite (runChecks la saute) : la session est la seule à pouvoir la jouer.
+    if (!gate.test)
+        return `The program's gate, played once by the program after your writing session, is exactly:\n${lines.join('\n')}\nThe program plays no test suite for this project: play the full suite yourself, once, before committing, and the build command as written, not a narrower one (\`npm run build\` may cover less than the gate). A red at the gate sends the lot back to a correction pass even when your own run was green.`;
+    return `The program's gate, played once by the program after your writing session, is exactly:\n${lines.join('\n')}\nPlay only the tests of the code you touch (targeted: one file or filter, never the full suite), once, before committing: the full suite is not yours to replay (L518). Play the build command as written, not a narrower one (\`npm run build\` may cover less than the gate). A red at the gate sends the lot back to a correction pass even when your own run was green.`;
 }
 /**
  * L'objectif d'un lot (L258) : celui gardé dans l'état du lot (`LotState.goal`, fixé au lancement : `--goal`, sinon la clé `goal:` du plan),

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) {