@sylad/cadence 1.27.0 → 1.29.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.27.0",
+      "version": "1.29.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.27.0",
+  "version": "1.29.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/README.md

@@ -48,7 +48,7 @@ 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 of sessions and their budgets.
+- [docs/orchestrate.md](docs/orchestrate.md): waves of sessions and their budgets, and which repositories a session may commit in.
 - [docs/deliver.md](docs/deliver.md): wait for the CI, deploy, verify the effect.
 - [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.

package/agents/doc-keeper.md

@@ -17,3 +17,20 @@ Follow the brief you are given. The method:
 5. **A document outside the repository** is yours only when the configuration says so: the brief then lists the entries of `docs.articles` (the cadence.yaml of the project: « this project is also described by this file of that repository », with the absolute path of the repository, open to you for reading). Never guess such a file, never go looking for one. Do not edit it, and never write to the plan of that repository (no `raf add`, no edit of its plan file): write a proposed lot instead — a title and a body that name the repository, the file, the passage and the sentence to change — and put it in the `resume` of your report, starting with « lot proposé ». The lead decides whether it enters that repository's plan.
 
 Never push, deliver, or run `raf done|start|note|review|ux`. Never run `git checkout` or `git switch` to another commit or branch in this repository. Do not launch subagents. Do not stop to ask: an interpretation you settle yourself goes under "choix" with the alternative you did not take. A document you could not check against the code goes under "nonVerifie". Give the report in the structured output the brief asks for.
+
+## Short reply
+
+Only when the brief carries a line `Report file: <absolute path>` (the lead, which keeps its context
+small by reading a report only when it needs to). That line is the only trigger; an orchestrated
+session and a call by hand without it have none.
+
+- The full report, with its measurements, is written to that file with Bash. Use the path the brief gives
+  and no other: it is outside the repository, so the working tree stays as you found it. The
+  verdict is the last line of the file. Write the file before you reply.
+- Reply to the caller with 15 lines at most, and nothing before or after them:
+  `Verdict: <the one-line verdict>`; `Findings:` one line per finding, most severe first, with its rank and the rule or the
+  measure it rests on (e.g. `README.md:12 — still says the old flag, `git show <sha>` line 40`); `Not verified: <what could not be run or seen>`
+  (`Not verified: none` when nothing); `Sub-tasks: <n> — <the lines to add to the plan, by their first words>`; `Report: <the path>`. A « lot proposé » for a document outside the repository goes in `Sub-tasks:` (title first), its body in the file.
+- If you cannot write the file, say so on the first line of the reply and give the whole report in the reply, as if
+  the brief had no report file: a verdict whose evidence nobody can read is lost.
+- With no `Report file:` line in the brief, give the complete report in your reply.

package/agents/ux-reviewer.md

@@ -98,3 +98,21 @@ A short report:
 - Judge on taste, or propose a new visual identity.
 - Report a finding you have not seen in a capture or measured.
 - Edit code, commit, or record `raf ux` yourself: the session that owns the lot does it.
+
+## Short reply
+
+Only when the brief carries a line `Report file: <absolute path>` (the lead, which keeps its context
+small by reading a report only when it needs to). That line is the only trigger; an orchestrated
+session and a call by hand without it have none.
+
+- The full report, with its measurements, is written to that file with Bash. Use the path the brief gives
+  and no other: it is outside the repository, so the working tree stays as you found it. The
+  verdict is the last line of the file. Write the file before you reply.
+- Reply to the caller with 15 lines at most, and nothing before or after them:
+  `Verdict: <the one-line verdict>`; `Findings:` one line per finding, most severe first, with its rank and the rule or the
+  measure it rests on (e.g. `major — /players: target 18×18 px, WCAG 2.5.8`); `Not verified: <what could not be run or seen>`
+  (`Not verified: none` when nothing); `Sub-tasks: <n> — <the lines to add to the plan, by their first words>`; `Report: <the path>`.
+  Add a last line `Captures: <the absolute path of the capture folder>` (the folder the brief names): the report file does not replace the captures, which the lead opens itself.
+- If you cannot write the file, say so on the first line of the reply and give the whole report in the reply, as if
+  the brief had no report file: a verdict whose evidence nobody can read is lost.
+- With no `Report file:` line in the brief, give the complete report in your reply.

package/dist/cli.js

@@ -22,7 +22,8 @@ import { dueLine, isRecurring, recurringByDue } from './recurring.js';
 import { schedule } from './schedule.js';
 import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.js';
 import { configSet } from './config-set.js';
-import { findProjects, readDepth, leadTour, readLeadUx, tourFreeLine, tourLine, tourNoTestLines, tourWorktreeLines } from './lead.js';
+import { movePriority } from './priority.js';
+import { findProjects, readDepth, leadTour, TITLE_MAX, truncate, readLeadUx, tourFreeLine, readLeadContextThreshold, 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';
@@ -53,6 +54,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   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"
+  --verbose             avec done, ux, review, note, move ou public : imprime la ligne « id  état  titre entier » du lot touché ; avec hook post-commit : le titre entier (sinon 60 caractères au plus)
   raf title <id> "nouveau titre"   remplace le titre d'un lot, de tout statut (done compris), et note l'ancien dans une note datée
   raf did <id> ["texte"]   un lot récurrent (--every) a été refait : le « dû depuis N j » repart de aujourd'hui
   raf ux enable         revue UX obligatoire avant « done » pour les lots --visible
@@ -74,6 +76,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--goal "…"] [--dry-run] [--wave nom] [--continue [--until HH:MM] [--priority a,b]]   une session claude neuve par étape ; --status [vague] [--watch [--interval s]] ; --resume [vague | --wave vague] [--budget 1M] [--budget projet:lot=+300k] [--answer projet:lot "réponse"] [--drop projet:lot] ; --drop projet:lot [--wave vague] ; --stop-after-current [--wave vague] ; --waits [--since AAAA-MM-JJ]
                         mode worktree par lot (orchestrate.worktrees: true)  (activé par défaut dans cadence, désactivé ailleurs tant que la clé est absente) ; ses options : --resume --wave <vague> --integrate projet:lot (rejoue un lot rendu à l'intégration) · --resume --wave <vague> --replay projet:lot (idem, et après une écriture de plan refusée) · --remove-worktree projet:lot [--abandon-commits] (retire le worktree et la branche conservés) ; la liste des worktrees conservés : orchestrate --status et lead tour
   cadence lead tour [dossier] [--idle 3] [--depth n] [--json]   le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan, ou la ligne du dossier seul s'il est lui-même un projet (en cours, dérive, notes de clôture, prochain lot prêt, dépôt), précédées de l'en-tête perf : une ligne par ⚠ de cadence perf, rien si tout est stable
+  cadence lead priority <projet> --before|--after <projet> [dossier] [--depth n]   range un projet dans la liste priority: du cadence.yaml du dossier (ordre du tour, de orchestrate --continue et du panneau des lots), commentaires gardés ; ne commite pas
   cadence lead hold <étiquette> [--ttl minutes] | lead release <étiquette>   déclare (60 min par défaut), puis rend, une session lancée à la main par le lead : elle est soustraite des créneaux libres de orchestrate --status et de lead tour ; au TTL échu, les deux la signalent en ⚠ jusqu'au release
   cadence corrections [dossier] [--classify [--model m]] [--cache fichier] [--cache-sous-causes fichier] [--sample n] [--until date] [--since date] [--json]   mesure des passes de correction des journaux dossier/.cadence/runs : lots à ≥1 et ≥2 corrections, par projet, visibles ou non, passes par cause (classées par Ollama avec --classify, hors quota)
   cadence perf [dossier] [--since date] [--json]   tableau de bord du workflow, sans modèle : deux fenêtres (7 derniers jours contre les 7 précédents) lues dans dossier/.cadence/runs et les plans, chaque vitesse à côté de sa qualité, ⚠ au-delà de 25 % de dégradation ; tokens par lot selon l'estimate, part de la revue, délais création → done → livraison, durée de mur par étape, coût en euros par lot livré (grille cadence.yaml perf.prices) ; --since est un jour qui tronque les fenêtres
@@ -197,6 +200,7 @@ function dispatch(argv, io) {
             ignored: { type: 'boolean' },
             notes: { type: 'boolean' },
             json: { type: 'boolean' },
+            verbose: { type: 'boolean' },
             classify: { type: 'boolean' },
             model: { type: 'string' },
             cache: { type: 'string' },
@@ -230,10 +234,12 @@ function dispatch(argv, io) {
     if (command === 'lead') {
         if (rest[0] === 'hold' || rest[0] === 'release')
             return leadHold(rest, values.ttl, io, today);
+        if (rest[0] === 'priority')
+            return leadPriority(rest, values.before, values.after, values.depth, io);
         if (values.ttl !== undefined)
             throw new RafError('--ttl ne va qu\'avec lead hold');
         if (rest[0] !== 'tour' || rest.length > 2)
-            throw new RafError('usage : cadence lead tour [dossier] [--idle 3] [--depth n] [--json] | lead hold <étiquette> [--ttl minutes] | lead release <étiquette>');
+            throw new RafError('usage : cadence lead tour [dossier] [--idle 3] [--depth n] [--json] | lead priority <projet> --before|--after <projet> [dossier] | lead hold <étiquette> [--ttl minutes] | lead release <étiquette>');
         const idle = values.idle === undefined ? undefined : Number(values.idle);
         if (idle !== undefined && !(Number.isInteger(idle) && idle >= 0))
             throw new RafError(`--idle invalide : ${values.idle}`);
@@ -460,6 +466,7 @@ function dispatch(argv, io) {
             io.out(`${rest[0]} → ${status}`);
             if (status === 'done')
                 warnIntegrating(root, io.err);
+            touchedLot(plan, rest[0], values.verbose, io);
             if (status === 'done' && !rest[0].includes('/')) {
                 const lot = plan.lot(rest[0]);
                 if (lot.visible && !loadEntries(newsDir).some((e) => e.lots.includes(lot.id))) {
@@ -515,6 +522,7 @@ function dispatch(argv, io) {
             plan.note(rest[0], rest.slice(1).join(' '), today);
             plan.save();
             warnIntegrating(root, io.err);
+            touchedLot(plan, rest[0], values.verbose, io);
             return 0;
         }
         case 'did': {
@@ -551,6 +559,7 @@ function dispatch(argv, io) {
             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();
+            touchedLot(plan, rest[0], values.verbose, io);
             return 0;
         }
         case 'public': {
@@ -562,6 +571,7 @@ function dispatch(argv, io) {
                 refuseLongTitle(rest.slice(1).join(' '));
             plan.setPublic(rest[0], values.clear ? null : rest.slice(1).join(' '));
             plan.save();
+            touchedLot(plan, rest[0], values.verbose, io);
             return 0;
         }
         case 'screen': {
@@ -600,7 +610,7 @@ function dispatch(argv, io) {
         }
         case 'ux':
         case 'review':
-            return gate(command, rest, loadPlan, root, today, io);
+            return gate(command, rest, loadPlan, root, today, io, !!values.verbose);
         case 'commits': {
             need(1, 'commits <lot>');
             const plan = loadPlan();
@@ -749,7 +759,7 @@ function dispatch(argv, io) {
                 return 0;
             }
             if (rest[0] === 'post-commit')
-                return postCommit(existsSync(planPath) ? loadPlan : null, newsDir, root, today, io, readHookConfig(configPath).autostart);
+                return postCommit(existsSync(planPath) ? loadPlan : null, newsDir, root, today, io, readHookConfig(configPath).autostart, !!values.verbose);
             if (rest[0] === 'pre-commit')
                 return preCommit(existsSync(planPath) ? loadPlan : null, readHookConfig(configPath).autostart, root, today, io);
             if (rest[0] === 'pre-push')
@@ -854,7 +864,7 @@ const GATES = {
     review: { on: 'revue de code obligatoire pour les lots à commits', already: 'revue de code déjà active' },
 };
 /** « raf ux … » et « raf review … » ont la même forme : activer la porte, ou noter le verdict d'un lot. */
-function gate(kind, rest, loadPlan, root, today, io) {
+function gate(kind, rest, loadPlan, root, today, io, verbose) {
     if (rest.length < 1)
         throw new RafError(`usage : raf ${kind} enable | ${kind} <lot> "verdict"`);
     const plan = loadPlan();
@@ -879,8 +889,19 @@ function gate(kind, rest, loadPlan, root, today, io) {
         plan.recordReview(rest[0], verdict, today, plan.readonly ? null : (lotWork(plan, root, rest[0])[0]?.sha ?? null), neighbours?.repos.length ? repoShas(plan, neighbours.repos, rest[0]) : undefined);
     }
     plan.save();
+    touchedLot(plan, rest[0], verbose, io);
     return 0;
 }
+/** Un titre de lot n'est jamais rendu en entier par défaut (L453) : ~300 caractères répétés à chaque commande, chaque commit de plan. */
+function shortTitle(title, verbose) {
+    return verbose ? title : truncate(title, TITLE_MAX);
+}
+/** `--verbose` (L453) : la ligne `id  état  titre entier` du lot touché par `done`, `ux`, `review`, `note`, `move`, `public` ; sans lui, rien de plus (une sous-tâche n'a pas de ligne). */
+function touchedLot(plan, id, verbose, io) {
+    const lot = verbose ? plan.lots().find((l) => l.id === id) : undefined;
+    if (lot)
+        io.out(`${lot.id}  ${lot.status}  ${lot.title}`);
+}
 function knownLot(plan, id, subtask) {
     const lot = plan.lots().find((l) => l.id === id);
     if (!lot)
@@ -1021,7 +1042,7 @@ function preCommit(load, mode, root, today, io) {
     }
     return 0;
 }
-function postCommit(load, newsDir, root, today, io, mode) {
+function postCommit(load, newsDir, root, today, io, mode, verbose) {
     if (!load)
         return 0;
     try {
@@ -1050,7 +1071,7 @@ function postCommit(load, newsDir, root, today, io, mode) {
             else if (lot.status === 'todo' && !planning)
                 io.err(`raf: ${r.lot} est encore todo${plan.readonly ? '' : ` — raf start ${r.lot}`}`);
             else
-                io.err(`raf: ${r.lot} (${lot.status}) ${lot.title}`);
+                io.err(`raf: ${r.lot} (${lot.status}) ${shortTitle(lot.title, verbose)}`);
         }
         const entries = loadEntries(newsDir);
         for (const id of new Set(refs.map((r) => r.lot))) {
@@ -1445,6 +1466,23 @@ function specReseal(args, reason, porteur, ctx, io) {
 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. */
 const HOLD_LABEL_MAX = 200;
+/** `cadence lead priority <projet> --before|--after <projet> [dossier]` (L449) : range un projet dans la liste `priority:` du cadence.yaml du dossier (celui du tour), sans modèle ni commit. */
+function leadPriority(rest, before, after, depth, io) {
+    const usage = 'usage : cadence lead priority <projet> --before|--after <projet> [dossier] [--depth n]';
+    if (rest.length < 2 || rest.length > 3 || (before === undefined) === (after === undefined))
+        throw new RafError(usage);
+    const place = before !== undefined ? 'before' : 'after';
+    const levels = depth === undefined ? undefined : Number(depth);
+    if (levels !== undefined && !(Number.isInteger(levels) && levels >= 1))
+        throw new RafError(`--depth invalide : ${depth} (un entier ≥ 1)`);
+    const parent = resolve(io.cwd, rest[2] ?? '.');
+    if (!existsSync(parent))
+        throw new RafError(`lead priority : dossier introuvable : ${parent}`);
+    const target = (before ?? after);
+    const moved = movePriority(parent, rest[1], place, target, levels);
+    io.out(moved.changed ? `${rest[1]} placé ${place === 'before' ? 'avant' : 'après'} ${target} dans priority: de ${join(parent, 'cadence.yaml')} (ordre : ${moved.order.join(' > ')}) — le fichier est modifié, à commiter` : `${rest[1]} est déjà ${place === 'before' ? 'avant' : 'après'} ${target} : rien à changer`);
+    return 0;
+}
 /** `cadence lead hold <étiquette> [--ttl minutes]` / `lead release <étiquette>` (L255) : inscrit, ou rend, une session lancée à la main par le lead, qui compte dans les créneaux libres. */
 function leadHold(rest, ttl, io, today) {
     const [verb, label] = rest;
@@ -1702,12 +1740,14 @@ async function sessionAll(rest, values, io) {
     }
     return worst;
 }
-/** Le contexte de la session de `--session <id>`, sinon de `CLAUDE_CODE_SESSION_ID`, sinon (variable absente) de la seule session du dossier courant, tel que la bande cadence-hud le publie ; illisible = code 2, à lire comme « au seuil ». */
+/** Le contexte (et sa position par rapport à `lead.contextThreshold`, en tokens) de la session de `--session <id>`, sinon de `CLAUDE_CODE_SESSION_ID`, sinon (variable absente) de la seule session du dossier courant, tel que la bande cadence-hud le publie ; illisible = code 2, à lire comme « au seuil ». */
 function sessionContext(io, session) {
     const r = readHudContext(io.env, io.now().getTime(), { cwd: io.cwd, session });
     if (!r.ok)
         throw new RafError(`session context : contexte illisible — ${r.reason} ; à traiter comme au seuil`);
     io.out(`ctx ${Math.round(r.ctx.percent)} % (${r.ctx.tokens}/${r.ctx.window})`);
+    const threshold = readLeadContextThreshold(io.cwd);
+    io.out(`seuil ${threshold} tokens : ${r.ctx.tokens >= threshold ? 'atteint' : 'sous le seuil'}`);
     return 0;
 }
 function session([sub, ...args], ctx, values) {

package/dist/config-set.js

@@ -6,7 +6,7 @@ import { isNode, isScalar, parse, parseDocument } from 'yaml';
 import { defaultPlan, readDocsConfig, readHookConfig, readMigrateConfig, readNewsConfig, readOrchestrateConfig, readPerfConfig, readPlanConfig, readReferencesConfig, readSessionConfig } from './config.js';
 import { parseDeliverConfig } from './deliver.js';
 import { commitPaths, dirtyPaths, gitRoot, restorePaths } from './git.js';
-import { findProjects, isProject, readDepth, readLeadUx } from './lead.js';
+import { findProjects, isProject, readDepth, readLeadContextThreshold, readLeadUx } from './lead.js';
 import { readPriority } from './orchestrate/continue.js';
 import { Plan, RafError } from './plan.js';
 const KEY = /^[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)*$/;
@@ -26,6 +26,7 @@ export function validateConfig(file, root) {
     readReferencesConfig(file);
     readMigrateConfig(file);
     readLeadUx(dirname(file));
+    readLeadContextThreshold(dirname(file));
     readDepth(dirname(file));
     readPriority(dirname(file));
     const text = readFileSync(file, 'utf8');

package/dist/config.js

@@ -338,7 +338,7 @@ export function readVerifyConfig(file) {
     return { inPlace: v.inPlace };
 }
 const REVIEW_KEYS = ['threshold', 'light', 'full'];
-const ORCH_KEYS = ['start', 'verdict', 'test', 'testReplay', 'build', 'worktreeDeps', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'prodAccess', 'worktrees', 'testGate', 'spec', 'review', 'escalation', 'continue', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'testReplay', 'build', 'worktreeDeps', 'gate', 'accept', 'maquette', 'maquetteReviews', 'fiche', 'ux', 'precheck', 'prodAccess', 'worktrees', 'testGate', 'spec', 'review', 'escalation', 'continue', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
 /** Clé `orchestrate:` de cadence.yaml. Absente : les défauts (auto, 45 min d'implémentation, 25 min de revue). */
 export function readOrchestrateConfig(file) {
     const config = { precheck: true, maquette: true, maquetteReviews: 3, fiche: true, precheckLocal: false, prodAccess: false, worktrees: false, spec: { dir: 'docs/specs' }, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', spec: 'medium', maquette: 'high', fiche: 'medium', accept: 'medium', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
@@ -392,6 +392,21 @@ export function readOrchestrateConfig(file) {
             throw bad('worktreeDeps : liste de chemins relatifs au dépôt, sans « .. » (node_modules, .venv…)');
         config.worktreeDeps = deps.map((x) => x.trim().replace(/\/$/, ''));
     }
+    if (o.gate != null) {
+        if (!isObject(o.gate))
+            throw bad('gate : objet attendu (gate: { readsPlan: true })');
+        for (const k of Object.keys(o.gate))
+            if (k !== 'readsPlan')
+                throw bad(`gate.${k} inconnu (attendu : readsPlan)`);
+        const r = o.gate.readsPlan;
+        const msg = 'gate.readsPlan : true, false ou liste de chemins de tests relatifs au dépôt, sans « .. »';
+        if (r === true)
+            config.gate = { readsPlan: true };
+        else if (Array.isArray(r) && r.length && r.every((x) => typeof x === 'string' && x.trim() && !isAbsolute(x) && !x.split(/[\\/]/).includes('..')))
+            config.gate = { readsPlan: r.map((x) => x.trim()) };
+        else if (r !== false)
+            throw bad(msg);
+    }
     if (o.maquette != null) {
         if (typeof o.maquette !== 'boolean')
             throw bad('maquette : true ou false attendu');

package/dist/lead.js

@@ -16,11 +16,11 @@ import { cadenceHome } from './orchestrate/registry.js';
 import { staleNotes, staleText } from './stale-notes.js';
 import { noTestGate, noTestText } from './orchestrate/no-test.js';
 import { KEPT_TITLE, keptLine, keptTrees } from './orchestrate/worktree.js';
-/** Clé `lead.ux` du cadence.yaml du dossier parent (L197) : qui pose le verdict UX (`raf ux`) d'un lot visible. `human` (défaut) : l'humain ; `lead` : le lead, l'humain n'étant consulté qu'en cas de doute. */
-export function readLeadUx(parent) {
+/** Le bloc `lead:` du cadence.yaml du dossier parent (absent = `undefined`) ; un `lead` qui n'est pas une table est refusé en nommant `key`. */
+function readLeadBlock(parent, key, expected) {
     const file = join(parent, 'cadence.yaml');
     if (!existsSync(file))
-        return 'human';
+        return undefined;
     let raw;
     try {
         raw = parse(readFileSync(file, 'utf8'));
@@ -30,16 +30,33 @@ export function readLeadUx(parent) {
     }
     const l = raw?.lead;
     if (l == null)
-        return 'human';
-    const ux = l.ux;
+        return undefined;
     if (typeof l !== 'object' || Array.isArray(l))
-        throw new RafError(`${file} : lead.ux doit être « lead » ou « human »`);
+        throw new RafError(`${file} : ${key} doit être ${expected}`);
+    return { file, block: l };
+}
+/** Clé `lead.ux` du cadence.yaml du dossier parent (L197) : qui pose le verdict UX (`raf ux`) d'un lot visible. `human` (défaut) : l'humain ; `lead` : le lead, l'humain n'étant consulté qu'en cas de doute. */
+export function readLeadUx(parent) {
+    const found = readLeadBlock(parent, 'lead.ux', '« lead » ou « human »');
+    const ux = found?.block.ux;
     if (ux == null)
         return 'human';
     if (ux !== 'lead' && ux !== 'human')
-        throw new RafError(`${file} : lead.ux doit être « lead » ou « human »`);
+        throw new RafError(`${found.file} : lead.ux doit être « lead » ou « human »`);
     return ux;
 }
+/** Seuil de contexte du lead quand `lead.contextThreshold` n'est pas posé (L437). */
+export const CONTEXT_THRESHOLD_DEFAULT = 150_000;
+/** Clé `lead.contextThreshold` du cadence.yaml du dossier (L437) : le nombre de tokens de contexte à partir duquel le lead ne lance plus de vague. En tokens et non en % : 60 % d'une fenêtre de 1M valait 600k. Un entier ≥ 1, sinon refus. */
+export function readLeadContextThreshold(parent) {
+    const found = readLeadBlock(parent, 'lead.contextThreshold', 'un entier ≥ 1 (tokens)');
+    const t = found?.block.contextThreshold;
+    if (t == null)
+        return CONTEXT_THRESHOLD_DEFAULT;
+    if (typeof t !== 'number' || !Number.isInteger(t) || t < 1)
+        throw new RafError(`${found.file} : lead.contextThreshold doit être un entier ≥ 1 (tokens), pas ${JSON.stringify(t)}`);
+    return t;
+}
 /** Clé `depth:` du cadence.yaml du dossier parent (L201, issue #8), à côté de `priority:` : combien de niveaux `lead tour` parcourt (1 : sous-dossiers directs, le défaut). */
 export function readDepth(parent) {
     const file = join(parent, 'cadence.yaml');

package/dist/orchestrate/briefs.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { RafError } from '../plan.js';
+import { wipBranch } from './tiers.js';
 /** Gabarits livrés avec le paquet (à la racine, à côté de dist/ et src/). */
 export const TEMPLATES_DIR = fileURLToPath(new URL('../../templates/orchestrate', import.meta.url));
 /** Consigne sur les dépôts voisins d'un lot (L62) : les sessions d'écriture y travaillent, les relectures y lisent les commits qui citent le lot. */
@@ -24,6 +25,14 @@ export function reposText(role, lot, repos) {
         `\`raf commits ${lot}\` lists them all; read the diff of the neighbouring ones with \`git -C <path> log\` / \`git -C <path> show\` (${repos.map((r) => `git -C ${r.path} log`).join(' ; ')}), and review them like the rest. You are read-only there too.`,
     ].join('\n');
 }
+/**
+ * Consigne des dépôts tiers (L456) d'une session d'écriture : jamais de commit sur la branche principale d'un autre dépôt que celui du lot et que ses voisins déclarés,
+ * cité par le lot ou non (cluster-sante L1 : 3 commits sur developpeur-gitops main le 30-10) ; la voie est `wip/<projet>-<lot>`. Le programme le contrôle en fin de session.
+ */
+export function tiersText(project, lot) {
+    const wip = wipBranch(project, lot);
+    return `Never commit on the main branch (\`origin/HEAD\`, \`main\` or \`master\`) of any repository other than this lot's own and the ones it declares with \`repos:\`, whether the lot's text cites that repository or not: a sibling repository of the projects folder is not yours to move (a GitOps repository can be one script away from production). If the lot's work needs a change there, create the branch \`${wip}\` in that repository and commit on it, never push, and say it under "choix". At the end of the session the program checks those repositories: a moved main branch hands the lot back to the lead, and the commit is not undone.`;
+}
 /** Revue courte du diff rebasé (L279, R17) : la branche du lot vient d'être rebasée sur celle du dépôt et son diff n'est plus celui que la revue a lu. */
 export function integrationText(base) {
     return `Integration re-review: this lot's branch was just rebased onto \`${base}\`, which moved while the lot was being written, and the diff of the lot is no longer the one an earlier review read (context changed or a conflict was resolved). Review the rebased diff only (\`git diff ${base}...HEAD\`): report a finding only for what the rebase changed or broke in the lot's own change. The program has already re-run the tests and the build on the rebased tip.`;

package/dist/orchestrate/cycle.js

@@ -2,11 +2,11 @@ import { spawn } from 'node:child_process';
 import { parse } from 'yaml';
 import { toolBinOf, withoutLaunchVars } from './snapshot.js';
 import { randomUUID } from 'node:crypto';
-import { delimiter, dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
+import { basename, delimiter, dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
 import { copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { coveredTasks, lotCommits, lotWork } from '../audit.js';
-import { readDocsConfig, readPlanConfig } from '../config.js';
+import { planLoader, readDocsConfig, readPlanConfig } from '../config.js';
 import { PLAN_ACTIONS, leadAnswerMessage, planCommitMessage } from '../plan-commit.js';
 import { articleRepoDir, articlesBrief, docSyncBrief, docSyncGaps, filesOf, gapMessage } from '../docsync.js';
 import { testGateMissing } from '../testgate.js';
@@ -19,7 +19,7 @@ import { isPlanOnly } from '../audit.js';
 import { compareBaseline, failedTests, hasUnnamedFailure } from './baseline.js';
 import { replayRed, TEST_WORKERS_ENV, testWorkersText } from './workers.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
-import { capturesText, gateText, headline, integrationText, localReading, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, tmpText } from './briefs.js';
+import { capturesText, gateText, headline, integrationText, localReading, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, 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';
@@ -36,6 +36,7 @@ import { decisionsText, humanDecisions } from './decisions.js';
 import { LOCAL_PRECHECK_UNREADABLE, PRECHECK_UNREADABLE, 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, takeTiers, tierMoved, tierRepos, wipBranch } from './tiers.js';
 import { branchExists, git, gitFailure, integrated, linkIgnored, lotBranch, planFileSet, planSeenFrom, prepareTree, removeTree, trackedDirty } from './worktree.js';
 /** Passes de correction au plus, puis la main est rendue au lead. */
 export const MAX_PASSES = 2;
@@ -571,7 +572,9 @@ function briefFor(c, kind, local = false) {
         if (l.pendingAnswer)
             vars.reponse = `Answer from the human to your earlier question: ${l.pendingAnswer}`;
     }
-    return renderBrief(briefName(l, kind, !!c.integration), vars, c.wave.templates);
+    const brief = renderBrief(briefName(l, kind, !!c.integration), vars, c.wave.templates);
+    // Les dépôts tiers (L456) : la consigne s'ajoute à tout brief d'écriture, sans passer par un gabarit (un gabarit modifié change l'empreinte que d'autres tests gardent).
+    return kind === 'implement' || kind === 'fix' || kind === 'spec' || kind === 'accept' ? `${brief}\n${tiersText(l.project, l.lot)}\n` : brief;
 }
 /** Tokens comptés par les sessions d'un lot (un lot repris compte ses étapes d'avant). */
 export const lotSpent = (l) => l.steps.reduce((n, s) => n + (s.tokens?.counted ?? 0), 0);
@@ -683,6 +686,7 @@ async function session(c, kind, local = false) {
     const before = await snapshot(wd(c));
     const neighbours = l.repos ?? [];
     const beforeOthers = await Promise.all(neighbours.map((r) => snapshot(r.path)));
+    const tiersBefore = write ? takeTiers(thirdRepos(c), (line) => w.log(`${lotKey(l.project, l.lot)} · ${line}`)) : null;
     const n = l.steps.length + 1;
     const sessionId = randomUUID();
     const step = { n, kind, model, ...(effort !== 'default' ? { effort } : {}), status: 'running', sessionId, started: new Date().toISOString(), headBefore: before.head ?? undefined };
@@ -873,6 +877,9 @@ async function session(c, kind, local = false) {
         writeFileSync(join(dir, `${base}.json`), outcome.stdout);
         writeFileSync(join(dir, `${base}.err`), outcome.stderr);
         step.report = `${base}.json`;
+        // Un commit sur la branche principale d'un dépôt tiers se dit aussi quand la session est en échec ou coupée au délai : sinon la relance le prendrait pour référence.
+        if (tiersBefore && checkTiers(c, kind, step, tiersBefore))
+            return null;
         step.status = 'failed';
         step.cause = outcome.cause;
         if (write && outcome.cause === 'délai dépassé') {
@@ -903,9 +910,11 @@ async function session(c, kind, local = false) {
     if (outcome.kind === 'quota') {
         if (outcome.firstStdout !== undefined)
             writeFileSync(join(dir, `${base}.first.json`), outcome.firstStdout);
+        w.quota = { hit: true, message: outcome.message };
+        if (tiersBefore && checkTiers(c, kind, step, tiersBefore))
+            return null;
         step.status = 'interrupted';
         step.cause = outcome.message;
-        w.quota = { hit: true, message: outcome.message };
         w.saveWave();
         c.lot.next = kind;
         transition(c, 'suspended', 'quota atteint');
@@ -953,6 +962,8 @@ async function session(c, kind, local = false) {
             return stop(c, 'failed', `incident : ${w.incident}`);
         }
     }
+    if (tiersBefore && checkTiers(c, kind, step, tiersBefore))
+        return null;
     for (const { where, path, before: b, after: a } of watched) {
         // Session d'écriture finie sur une autre branche ou en HEAD détaché (L214) : pas un push, mais les contrôles et le lot suivant partiraient d'un HEAD qui n'est plus la branche du lot.
         if (write && b.branch !== a.branch) {
@@ -1019,6 +1030,53 @@ async function session(c, kind, local = false) {
     save(c);
     return { step, report: res.structured, before, after, others };
 }
+/** Les dépôts tiers d'un lot (L456) : frères du dépôt du lot, hors voisins déclarés et dépôts des autres lots de la vague, ou d'une autre vague en cours du même dossier (leur branche principale bouge légitimement, R14). */
+function thirdRepos(c) {
+    const mine = lotKey(c.lot.project, c.lot.lot);
+    const others = [...c.wave.store.lots().filter((x) => lotKey(x.project, x.lot) !== mine), ...c.wave.store.liveWaveLots()].flatMap(lotRepoPaths);
+    return tierRepos(c.lot.repo, [...neighbourDirs(c.lot), ...others]);
+}
+/**
+ * Fin d'une session d'écriture (L456) : la branche principale d'un dépôt tiers a-t-elle bougé ? Alors le lot est rendu avec le constat, le commit n'est pas défait,
+ * le dépôt est marqué sale pour la vague. Un tiers resté sur la branche wip du lot est dit en avertissement, sans être remis. Un dépôt illisible ou sans branche
+ * principale des deux côtés est ignoré, au journal. Vrai quand le lot est rendu : la session s'arrête là.
+ */
+function checkTiers(c, kind, step, before) {
+    const l = c.lot;
+    const w = c.wave;
+    const key = lotKey(l.project, l.lot);
+    const wip = wipBranch(l.project, l.lot);
+    for (const [repo, b] of before) {
+        const name = basename(repo);
+        let a;
+        try {
+            a = readTier(repo);
+        }
+        catch (e) {
+            w.log(`${key} · dépôt tiers ${name} ignoré : lecture impossible (${gitFailure(e)})`);
+            continue;
+        }
+        if (!Object.keys(b.mains).length && !Object.keys(a.mains).length) {
+            w.log(`${key} · dépôt tiers ${name} ignoré : aucune branche principale`);
+        }
+        else {
+            const moved = tierMoved(repo, b, a, relative(l.repo, c.loadPlan().path));
+            if (moved) {
+                step.status = 'failed';
+                step.cause = `commit sur la branche principale d'un autre dépôt (${name}, ${moved.branch})`;
+                (w.dirtyRepos ??= new Map()).set(repo, key);
+                stop(c, 'handed-back', `incident : commit sur la branche principale d'un autre dépôt (${name}, ${moved.branch}) pendant ${key} (${kind}) : ${moved.detail} ; la voie est la branche ${wip}`);
+                return true;
+            }
+        }
+        if (a.branch === wip && b.branch !== wip) {
+            const text = `${kind} : la session a laissé le dépôt tiers ${name} sur la branche ${wip} ; elle n'est pas remise`;
+            l.warnings.push(text);
+            w.log(`${key} · ${text}`);
+        }
+    }
+    return false;
+}
 /**
  * Une session d'écriture a-t-elle touché, dans son worktree, le fichier de plan ou un fichier généré avec lui (plan.files, la page Gantt) ? (R21) Le plan n'est
  * écrit que par le programme, dans le dépôt du projet : un commit de plan sur la branche du lot reviendrait en conflit au rebase. Rend « (fichier, commit sha) »
@@ -2318,15 +2376,42 @@ async function work(c, kind) {
 const noCommitNote = (l) => (l.warnings.some((w) => w.startsWith('passe des mineurs sans commit')) ? ' sans commit' : '');
 /** Revue de code qui clôt le cycle : complète, ou courte une fois la passe des mineurs jouée. */
 const codeReview = (l) => (l.minorPass ? 'review-small' : 'review');
+/** Note d'un lot que sa session a rendu `visible` après le lancement de la vague (L454) : son verdict UX n'existe pas encore, le lead le sait. */
+const VISIBLE_ADDED = 'visible ajouté en cours de vague, étape UX à jouer';
+/**
+ * Relit `visible` dans le plan du worktree après une session d'écriture (L454) : un lot que sa session a rendu visible (warhammer L37 et L43,
+ * 30-10) est lancé non visible, et sortait « prêt » sans étape UX. Il le devient dans l'état du lot, donc l'UX est jouée (`uxAfterReview`, ou la
+ * revue courte d'un petit lot) ; sans application déclarée, il est rendu avec la note. Un plan illisible, ou un lot qui n'est plus visible
+ * dans le plan, laisse l'état tel quel (retirer `visible` en cours de vague n'est pas traité).
+ */
+function addedVisible(c) {
+    const l = c.lot;
+    if (l.visible)
+        return;
+    let now;
+    try {
+        now = (wd(c) === l.repo ? c.loadPlan() : planLoader(wd(c))()).lot(l.lot).visible;
+    }
+    catch {
+        return;
+    }
+    if (!now)
+        return;
+    l.visible = true;
+    if (!c.config.ux)
+        l.uxNote = `${VISIBLE_ADDED} (aucune application déclarée : cadence.yaml orchestrate.ux)`;
+    c.wave.log(`${lotKey(l.project, l.lot)} · ${VISIBLE_ADDED}`);
+}
 /**
  * Première étape après un travail d'écriture (L221) : la revue de code, jamais l'UX. La revue UX d'un lot visible est jouée une seule fois,
  * après la dernière revue de code conforme (`uxAfterReview`), sur le code qui sera livré.
  */
 function firstReview(c) {
     const l = c.lot;
+    addedVisible(c);
     if (l.small)
         return l.visible || l.minorPass ? 'review-small' : 'review'; // passe unique code + ergonomie ; sans écran, une revue de code
-    if (l.visible && !c.config.ux)
+    if (l.visible && !c.config.ux && !l.uxNote?.startsWith(VISIBLE_ADDED))
         l.uxNote = 'UX à faire par le lead (aucune application déclarée : cadence.yaml orchestrate.ux)';
     return codeReview(l);
 }

package/dist/orchestrate/state.js

@@ -3,6 +3,7 @@ import { appendFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdir
 import { tmpdir } from 'node:os';
 import { join, relative } from 'node:path';
 import { gitCommonDir, gitRoot } from '../git.js';
+import { pidAlive } from '../state.js';
 /** Début de l'avertissement d'un rapport de précheck illisible (Sonnet) : le journal le garde, `cadence perf` s'en sert pour ne pas compter ce lot « non » (L293). */
 /** 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';
@@ -127,6 +128,12 @@ export class RunStore {
         const f = join(this.dir, lotFile(project, lot));
         return existsSync(f) ? JSON.parse(readFileSync(f, 'utf8')) : null;
     }
+    /** Les lots des AUTRES vagues en cours du même dossier de lancement (L456) : vague `running` dont le processus vit. Leurs dépôts avancent sans que cette vague y soit pour rien. */
+    liveWaveLots() {
+        return RunStore.all(this.launchDir)
+            .filter(({ store, wave }) => store.id !== this.id && wave?.status === 'running' && pidAlive(wave.pid))
+            .flatMap(({ store }) => store.lots());
+    }
     /** Les lots de la vague, dans l'ordre donné au lancement (`wave.lots`) : une reprise rejoue les dépendances avant les dépendants. */
     lots() {
         const all = readdirSync(this.dir)