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

package/README.md

@@ -24,7 +24,7 @@ Code prompt that shows the session's context, quota, cost and the orchestrate wa
 
 ## What's new
 
-**0.20.0**: `cadence-hud` no longer misleads once the work is over: `/hud cmd` lists the background commands it counts (id, tool, origin, age, name), any other argument answers `argument inconnu` instead of hiding the band, commands with no end seen for an hour or no record go to a grey `N cmd sans fin vue`, a finished subagent takes its commands with it, two races that left a `1 cmd` counted forever are closed, and a finished wave shows grey without its budget then disappears after 30 minutes (L142); the `qa-reviewer` and `ux-reviewer` agents are read-only for real, their frontmatter listing Read, Grep, Glob, Bash and the Playwright tools (L140). **0.19.1**: `cadence-hud`'s `N cmd` counter goes back down when a Monitor expires, when the background commands a subagent started end with it, and at session start or plugin reload (L135); its `tool.call` and `prompt.submit` guard hooks carry a `.catch` on registration, which clears the `claude plugin validate` warning (L136). **0.19.0**: `cadence orchestrate` lifts a repository's lock and `pre-push` guard as soon as every lot of the wave that touches it is finished, so `cadence deliver` works there while the wave continues elsewhere (L132); a review that leaves a repository dirty hands back that lot only, suspends the lots still queued in that repository and keeps the other repositories running, its verdict reported instead of lost (L133); `cadence session close` re-run without a `session start` keeps the window since the last opening (L131); `cadence-hud` draws the lot rows of a wave in aligned columns on every surface (L134). **0.18.0**: `cadence session next` prints what it records (issue #6); `cadence session close` covers the period since the last `session start` (or the last close) and says so in its title, `--since` still wins (issue #7). **0.17.0**: `cadence-hud` shows an `N cmd` segment next to the agents, the background commands of the session (Bash run in the background and Monitor, subagents' included), tracked from the tool results and ended by the task's notification or `TaskStop`. **0.16.0**: a lot can declare **neighbouring repositories** (`repos:` key of the lot, `{ path, cite }` for a repository shared between projects): `cadence orchestrate` refuses, locks and guards them, gives them to every session as `--add-dir`, and `raf commits`, `raf show` and the review verdict read the commits that cite the lot there too. **0.15.0**: `hook.autostart` in `cadence.yaml` (`warn` by default, `refuse` or `start`): a pre-commit hook that refuses, or starts in the same commit, a lot still todo that the commit cites; `cadence session start|close --all [--depth n]`, one section per project under a folder. **0.14.0**: `cadence lead tour`, the lead's morning table of every project in a folder, printed by a program (one line per project: lots in progress, gaps, last notes, next ready lot, repository) in place of one subagent per project; the `lead` skill calls it. **0.13.1**: `cadence-hud` takes back the segments that fit once a big one has dropped (reset times, then the per-model consumption, now short: `opus 1.2M sonnet 800k`); `CADENCE_HUD_AMBIGUOUS=1` for a terminal that draws `▰ ▱ ⚙ │ ↻` in one cell. **0.13.0**: `cadence orchestrate --status --watch` (a wave's table redrawn in the terminal, which
+**0.21.0**: `cadence orchestrate --status` and `cadence lead tour` print the free session slots, which the `lead` skill reads (L141); `orchestrate.effort` sets the effort level of each pass of a wave (L137); `docs.sync` makes `raf check`, `lead tour` and the review brief report a document that does not follow the code (L143); `docs.articles` opens, after a green `cadence deliver`, a lot `Article <project> à rafraîchir` in the neighbouring repository (L144). **0.20.0**: `cadence-hud` no longer misleads once the work is over: `/hud cmd` lists the background commands it counts (id, tool, origin, age, name), any other argument answers `argument inconnu` instead of hiding the band, commands with no end seen for an hour or no record go to a grey `N cmd sans fin vue`, a finished subagent takes its commands with it, two races that left a `1 cmd` counted forever are closed, and a finished wave shows grey without its budget then disappears after 30 minutes (L142); the `qa-reviewer` and `ux-reviewer` agents are read-only for real, their frontmatter listing Read, Grep, Glob, Bash and the Playwright tools (L140). **0.19.1**: `cadence-hud`'s `N cmd` counter goes back down when a Monitor expires, when the background commands a subagent started end with it, and at session start or plugin reload (L135); its `tool.call` and `prompt.submit` guard hooks carry a `.catch` on registration, which clears the `claude plugin validate` warning (L136). **0.19.0**: `cadence orchestrate` lifts a repository's lock and `pre-push` guard as soon as every lot of the wave that touches it is finished, so `cadence deliver` works there while the wave continues elsewhere (L132); a review that leaves a repository dirty hands back that lot only, suspends the lots still queued in that repository and keeps the other repositories running, its verdict reported instead of lost (L133); `cadence session close` re-run without a `session start` keeps the window since the last opening (L131); `cadence-hud` draws the lot rows of a wave in aligned columns on every surface (L134). **0.18.0**: `cadence session next` prints what it records (issue #6); `cadence session close` covers the period since the last `session start` (or the last close) and says so in its title, `--since` still wins (issue #7). **0.17.0**: `cadence-hud` shows an `N cmd` segment next to the agents, the background commands of the session (Bash run in the background and Monitor, subagents' included), tracked from the tool results and ended by the task's notification or `TaskStop`. **0.16.0**: a lot can declare **neighbouring repositories** (`repos:` key of the lot, `{ path, cite }` for a repository shared between projects): `cadence orchestrate` refuses, locks and guards them, gives them to every session as `--add-dir`, and `raf commits`, `raf show` and the review verdict read the commits that cite the lot there too. **0.15.0**: `hook.autostart` in `cadence.yaml` (`warn` by default, `refuse` or `start`): a pre-commit hook that refuses, or starts in the same commit, a lot still todo that the commit cites; `cadence session start|close --all [--depth n]`, one section per project under a folder. **0.14.0**: `cadence lead tour`, the lead's morning table of every project in a folder, printed by a program (one line per project: lots in progress, gaps, last notes, next ready lot, repository) in place of one subagent per project; the `lead` skill calls it. **0.13.1**: `cadence-hud` takes back the segments that fit once a big one has dropped (reset times, then the per-model consumption, now short: `opus 1.2M sonnet 800k`); `CADENCE_HUD_AMBIGUOUS=1` for a terminal that draws `▰ ▱ ⚙ │ ↻` in one cell. **0.13.0**: `cadence orchestrate --status --watch` (a wave's table redrawn in the terminal, which
 stops with the wave) and the lead skill that names the wave and follows its journal; lot ids with `/`
 (sub-tasks of a read-only plan) accepted by `orchestrate`; `cadence-hud`'s first line measured in
 terminal cells and kept to ASCII; `publish.yml` on the v5 actions. **0.12.0**: the `cadence-hud` plugin (a status band above the Claude Code prompt),
@@ -341,6 +341,64 @@ lot in each neighbour (the one `raf commits` lists last: it cites the lot, falls
 neighbour has none), and refuses to record when a listed repository cannot be read. `raf check` does not audit the
 neighbours: their staleness is not checked, only the project's own commits are.
 
+### Documentation that follows the code
+
+A stale README misleads. `cadence.yaml` can declare which documents must follow which code:
+
+```yaml
+docs:
+  sync:
+    - paths: [src/**, bin/*.js]        # what changes…
+      docs: [README.md, docs/usage.md]  # …must change one of these, in the same lot
+    - paths: [templates/]
+      docs: [CLAUDE.md]
+    - paths: [frontend/src/**, '!**/*.test.tsx']   # a pattern starting with ! leaves files out
+      docs: [README.md]
+  since: 2026-10-09                    # optional: also audit lots finished on or after this day
+```
+
+A pattern is an exact path, with `*` (inside a folder), `**` (across folders), `?`, or a trailing `/` for
+a whole folder. `raf check` takes the **work commits** of every lot in progress (plan-only commits do
+not count; a lot finished on or after `docs.since` is audited too) and, for each pair, reports the lot when
+those commits touch `paths` without any of them touching a file of `docs`:
+
+```
+✗ L7 : documentation en retard — src/a.ts, src/b.ts sans toucher README.md ou docs/usage.md (docs.sync)
+```
+
+It counts as drift: exit code 1, shown in the `dérive` column of `cadence lead tour`, and the review
+brief of `cadence orchestrate` (`review` and `review-small`) carries the list the program computed,
+to be reported as one **major** finding per line — a stale document is not left to the reviewer's
+memory of a sentence. Touching a document is what the program checks; whether its text is true is
+still the review's reading. The commits of neighbouring repositories (`repos:`) are not audited.
+
+#### An article elsewhere that follows the delivery
+
+A case study that lives in a neighbouring repository (the project's article on a showcase site) goes stale
+the same way. `docs.articles` names it:
+
+```yaml
+docs:
+  articles:
+    - repo: ../claude-code-codex          # neighbouring repository, relative to the project
+      file: src/pages/cas/demo.md         # the article in it
+      name: demo                          # optional: the name in the lot title (default: the plan's project)
+```
+
+After a **green** `cadence deliver`, for the lots it lists as delivered **that have a public title** (`public:`, or
+the title of their Nouveautés entry), cadence opens in this repository's plan the lot
+`Article demo à rafraîchir` (todo, estimate 0.5, `repos: [{ path: ../claude-code-codex, cite: demo }]`), with a note
+that quotes the delivery, the public titles delivered, the article and the **sections to read again**: the headings
+(`#` lines, or `<h1>`…`<h6>` of an Astro page) that share a word of five letters or more with a delivered title,
+else all the `##` headings. The lot is then played like any other, in an ordinary wave (`cadence orchestrate`: an
+implementer rewrites the article in the neighbouring repository, the review checks it against the note). If a lot
+of that title is still open, it receives a note instead of a duplicate. Two entries with the same name (the same
+project told in two neighbouring repositories) share one lot, which declares both repositories in `repos:`. Internal lots (no public title) open nothing;
+a red delivery opens nothing; `cadence deliver --dry-run` announces the articles. The plan is written but **not
+committed** (`deliver` never commits): the line `article à rafraîchir : L9 …` says so. With a plan kept by another
+tool (read-only), the same line carries the instruction to open the lot with that tool. This replaces the manual
+`sync-site-docs` skill.
+
 ### QA review
 
 No gate and no command here: the QA review comes **after** a delivery, and
@@ -525,11 +583,13 @@ beta · en cours rien · dérive aucune · notes : aucune · prochain T2 Second
 | Column | Content |
 |---|---|
 | `en cours` | ids of the lots in progress; `(aucune activité)` when it has none at all, `(silencieux Nj)` when the lot's last activity (commit, note or start) is more than `--idle` days old (default 3) |
-| `dérive` | the gaps `raf check` reports, counted and the first two shown |
+| `dérive` | the gaps `raf check` reports (a lot whose commits leave a document behind, [`docs.sync`](#documentation-that-follows-the-code), included), counted and the first two shown |
 | `notes` | the notes left by the last `session close`, joined with ` / ` and cut at 120 characters |
 | `prochain` | the first ready lot (quick wins first) — id and title cut at 60 characters |
 | `dépôt` | `non commité` (modified or untracked files), `non poussé` (commits ahead of the upstream), `livraison en cours` (live delivery lock); `propre` otherwise |
 
+When an orchestrated wave is live, one more line closes the tour (not part of `--json`): `vagues en cours : 1 · sessions en cours : 0 · créneaux libres : 1 sur 2` — the lead reads the free slots there instead of computing them (L141).
+
 `--json` prints the same content as an array of objects (`project`, `doing`, `drift`, `notes`,
 `next`, `repo`, and `error` when the project could not be read). The tour is read-only: it changes
 no plan. It exits 0 even when a project is in error — that project's line reads
@@ -634,6 +694,8 @@ cadence deliver              # 0 delivered and verified · 1 a step failed · 2
   reservation number that looks like one) is not a delivered lot. Plan upkeep
   commits (see "Plan upkeep needs no lot") are skipped in that list: they cite
   lots without delivering anything.
+- With [`docs.articles`](#an-article-elsewhere-that-follows-the-delivery), a green delivery of lots with a
+  public title also opens the lot `Article <project> à rafraîchir` in the plan.
 
 ### A project with its own delivery script
 
@@ -796,6 +858,22 @@ orchestrate:
 
 `full` is also the model of the UX review and of the single pass of a small lot that is not light.
 
+**Effort level per pass** (L137). Each session is launched with `claude -p --effort <level>` (Claude Code 2.1.284; an
+older `claude` is refused at launch unless every pass is `default`). Defaults: `precheck` low (it only reads),
+`implement` and `fix` medium, `review` high (`review-small` follows `review`), `ux` high. A project overrides any of them
+in `cadence.yaml`; the levels are `low`, `medium`, `high`, `xhigh`, `max`, and `default` sends no `--effort` (the
+level of the session, as before this key). The format-retry session (`--resume`) keeps the level of its pass, and
+`--dry-run` shows the flag in each command line.
+
+```yaml
+orchestrate:
+  effort: { precheck: low, implement: medium, fix: medium, review: high, ux: high }   # defaults
+```
+
+To measure what a level costs, run the same kind of wave before and after changing the key: each step of
+`<wave>/<project>--<lot>.json` records its `effort`, its `tokens` and its `started` / `ended` times (a step from a wave
+older than L137, or with `default`, has no `effort`); compare the totals per `kind` between the two waves.
+
 **Pre-check « deliverable already present? »** (L77). Before the first implementation of a lot that has no commit yet, a
 short read-only session (Sonnet, `precheck` step, brief `templates/orchestrate/precheck.md`) looks in the repository for
 what the lot asks for (another lot, or a correction, may have done it already). It answers `oui` (everything is there,
@@ -919,7 +997,7 @@ A slot or a registry entry is owned by a pid **and** its start time: a reused pi
 identifiers are reserved atomically (`-2`, `-3` suffix when two waves start in the same minute; an existing
 `--wave` is refused). The registry of live waves and the slots live under `~/.cadence/orchestrate/` (`CADENCE_HOME`
 to move it): `cadence orchestrate --status` lists, from any folder, the live waves, the repositories each
-still holds (those not yet released), the cap of each wave and the slots in use.
+still holds (those not yet released), the cap of each wave, the slots in use and the **free slots** (`créneaux libres : N sur 2`: 2 minus, for each live wave, the smaller of its cap and the repositories it still holds — the figure the `lead` skill reads before starting a subagent). Without an identifier it then prints the table of the wave launched most recently from this folder (by launch time, not by alphabetical order of the identifier).
 
 **Guards, imposed by the code**: a global cap of simultaneous sessions, one wave per repository at
 a time (above); `Agent`, `git push`, `cadence deliver`, `raf done|review|ux` are denied to the sessions; a
@@ -964,6 +1042,7 @@ orchestrate:
   test: npm test                         # run by the orchestrator after a work step (optional)
   build: npm run build                   # run after the tests; both results go to the reviewer, who does not redo them (optional)
   precheck: true                         # default: before the first implementation of a lot with no commit, a read-only Sonnet session checks whether the deliverable is already in the repository (see below); false skips it
+  effort: { review: xhigh }              # effort level per pass (see « Effort level per pass »): precheck, implement, fix, review, ux
   ux: http://localhost:4200              # a URL, a launch command, or { command, url, timeout? } — for the UX review (see below)
   permissionMode: auto                   # default
   addDirs: [/home/me/projects/tmp]       # extra directories the sessions may use

package/dist/articles.js

@@ -0,0 +1,86 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { isOpen } from './plan.js';
+/** Titre du lot ouvert à la livraison. */
+export const articleTitle = (name) => `Article ${name} à rafraîchir`;
+const SECTIONS_SHOWN = 12;
+/** Titres d'un article : lignes `#` du Markdown (hors en-tête YAML) et balises `<h1>`…`<h6>` d'une page Astro ou MDX. */
+export function articleHeadings(text) {
+    const body = text.replace(/^/, '').replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '');
+    const found = [];
+    for (const m of body.matchAll(/^(#{1,6})[ \t]+(.+?)[ \t]*#*[ \t]*$/gm))
+        found.push({ at: m.index, heading: { level: m[1].length, text: m[2].trim() } });
+    for (const m of body.matchAll(/<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi)) {
+        const t = m[2].replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim();
+        if (t)
+            found.push({ at: m.index, heading: { level: Number(m[1]), text: t } });
+    }
+    return found.sort((a, b) => a.at - b.at).map((f) => f.heading);
+}
+const words = (s) => new Set(s
+    .normalize('NFD')
+    .replace(/[̀-ͯ]/g, '')
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((w) => w.length >= 5));
+/**
+ * Sections à relire : celles dont le titre partage un mot (5 lettres au moins, sans accents ni casse) avec un titre public
+ * livré ; sans recoupement, toutes les sections de premier niveau (`##`), faute de mieux.
+ */
+export function articleSections(text, titles) {
+    const headings = articleHeadings(text);
+    const wanted = new Set(titles.flatMap((t) => [...words(t)]));
+    const matching = headings.filter((h) => [...words(h.text)].some((w) => wanted.has(w))).map((h) => h.text);
+    const picked = matching.length ? matching : headings.filter((h) => h.level === 2).map((h) => h.text);
+    return picked.slice(0, SECTIONS_SHOWN);
+}
+/**
+ * Après une livraison verte (L144) : pour chaque article déclaré, ouvre dans ce dépôt le lot « Article <projet> à rafraîchir »
+ * — ou, s'il en est déjà un d'ouvert, y ajoute une note. La note cite les titres publics livrés et les sections à relire ;
+ * le lot déclare le ou les dépôts voisins (`repos`, filtrés par le nom du projet : le dépôt de l'article est partagé entre projets).
+ * Les entrées de même nom partagent un seul lot, qui déclare tous leurs dépôts.
+ * Ne sauve pas le plan. Aucun titre public livré : rien à rafraîchir.
+ */
+export function openArticleLots(o) {
+    const result = { opened: [], noted: [], manual: [], warnings: [] };
+    const titles = [...new Set(o.delivered.map(o.publicTitle).filter((t) => !!t))];
+    if (!titles.length)
+        return result;
+    // Un lot par nom de projet : deux articles de même nom (deux dépôts voisins) se jouent ensemble dans le même lot.
+    const byName = new Map();
+    for (const rule of o.rules) {
+        const name = rule.name ?? o.plan.project;
+        byName.set(name, [...(byName.get(name) ?? []), rule]);
+    }
+    for (const [name, rules] of byName) {
+        const title = articleTitle(name);
+        const repos = [...new Set(rules.map((r) => r.repo))];
+        const articles = rules.map((rule) => {
+            const path = resolve(o.root, rule.repo, rule.file);
+            const sections = existsSync(path) ? articleSections(readFileSync(path, 'utf8'), titles) : null;
+            if (sections === null)
+                result.warnings.push(`article introuvable : ${path}`);
+            return (`Article : ${rule.repo}/${rule.file}. ` +
+                (sections === null ? 'Fichier introuvable à l\'ouverture du lot : vérifier le chemin (docs.articles). ' : `Sections à relire : ${sections.length ? sections.join(' ; ') : '(aucun titre trouvé : relire tout l\'article)'}. `));
+        });
+        const note = `Livraison ${o.sha.slice(0, 7)} : titres publics livrés ${titles.map((t) => `« ${t} »`).join(', ')}. ` +
+            articles.join('') +
+            `Réécrire ce que ces changements rendent faux ou incomplet, sans rien inventer ; les commits ${repos.length > 1 ? 'des dépôts' : 'du dépôt'} ${repos.join(', ')} citent le lot et « ${name} ».`;
+        if (o.plan.readonly) {
+            result.manual.push(`${title} — plan tenu par un autre outil, ouvrir le lot avec lui : ${note}`);
+            continue;
+        }
+        const open = o.plan.lots().find((l) => l.title === title && isOpen(l.status));
+        if (open) {
+            o.plan.note(open.id, note, o.today);
+            result.noted.push(open.id);
+            continue;
+        }
+        const id = o.plan.add(title, o.today, { estimate: 0.5 });
+        o.plan.setRepos(id, repos.map((path) => ({ path, cite: name })));
+        o.plan.note(id, note, o.today);
+        result.opened.push(id);
+    }
+    return result;
+}
+export const describeArticle = (rule) => join(rule.repo, rule.file);

package/dist/audit.js

@@ -4,7 +4,8 @@ import { check } from './check.js';
 import { parse } from 'yaml';
 import { changedFiles, fileAt, readCommits } from './git.js';
 import { linkCommits } from './link.js';
-import { readNewsConfig } from './config.js';
+import { readDocsConfig, readNewsConfig } from './config.js';
+import { docSyncGaps, filesOf, gapMessage } from './docsync.js';
 import { loadEntries, newsIssues, PUBLIC_TITLE_DEFAULT, publicTitleTooLong, reusedNewsTitle } from './news.js';
 import { isRecurring } from './recurring.js';
 import { isOpen } from './plan.js';
@@ -109,11 +110,24 @@ export function audit(plan, root, newsDir, today, opts = {}) {
         const m = l.public ? publicTitleTooLong(l.public, max) : reused ? publicTitleTooLong(reused, max) : null;
         return m ? [{ message: `${l.id} : ${reused && !l.public ? m.replace('titre public', 'titre public repris de la Nouveauté') : m}` }] : [];
     });
-    const issues = [...check(lots, { ...linked, byLot: all.byLot }, today, opts.idle ?? 7), ...newsIssues(lots, entries, newsDir), ...titles, ...gates, ...(plan.hasPublicField ? missingPublicTitles(lots, entries) : []),
+    const issues = [...check(lots, { ...linked, byLot: all.byLot }, today, opts.idle ?? 7), ...newsIssues(lots, entries, newsDir), ...titles, ...gates, ...docSyncIssues(plan, root, all.byLot), ...(plan.hasPublicField ? missingPublicTitles(lots, entries) : []),
         ...plan.ignore.invalid.map((src) => ({ message: `ignore : motif invalide « ${src} »` }))];
     // Un plan en lecture seule se corrige avec l'outil du projet : ne pas conseiller une commande raf qui refuserait.
     return plan.readonly ? issues.map((i) => ({ ...i, message: i.message.replace(/ — raf (start|public) .*$/, '') })) : issues;
 }
+/**
+ * Documentation en retard (L143, clé `docs.sync`) : un lot en cours — ou terminé à partir de `docs.since` — dont les commits de
+ * travail touchent des chemins sans toucher le document que la règle désigne. Les commits de plan ne comptent pas.
+ */
+export function docSyncIssues(plan, root, byLot) {
+    const { sync, since } = readDocsConfig(plan.configFile ?? join(root, 'cadence.yaml'));
+    if (!sync.length)
+        return [];
+    return plan
+        .lots()
+        .filter((l) => l.status === 'doing' || (l.status === 'done' && !!since && !!l.finished && l.finished >= since))
+        .flatMap((l) => docSyncGaps(sync, filesOf(root, workCommits(plan, root, byLot.get(l.id) ?? []))).map((g) => ({ message: gapMessage(l.id, g) })));
+}
 /** Commits qui portent du travail sur un lot : ni antérieurs à l'adoption du plan, ni réduits au plan. */
 function workCommits(plan, root, commits) {
     const adopted = plan.since;

package/dist/cli.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
-import { readHookConfig, readNewsConfig, readPlanConfig, readSessionConfig } from './config.js';
+import { readDocsConfig, readHookConfig, readNewsConfig, readPlanConfig, readSessionConfig } from './config.js';
 import { repoSections, repoShas, resolveLotRepos } from './repos.js';
 import { audit, exemptPlanOnly, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
 import { short } from './check.js';
@@ -18,7 +18,7 @@ import { dueLine, isRecurring, recurringByDue } from './recurring.js';
 import { schedule } from './schedule.js';
 import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.js';
 import { findProjects, leadTour, tourLine } from './lead.js';
-import { orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
+import { liveLines, orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
 import { activeLock, REPO_LOCK } from './orchestrate/lock.js';
 import { sessionClose, sessionStart } from './session.js';
 import { clearNext, readNext, sharedStateDir, stateDir, writeNext } from './state.js';
@@ -155,9 +155,14 @@ function dispatch(argv, io) {
             io.out(JSON.stringify(rows, null, 2));
         else if (rows.length === 0)
             io.out(`aucun projet sous ${parent} (docs/plan/raf.yaml ou cadence.yaml avec plan:)`);
-        else
+        else {
             for (const r of rows)
                 io.out(tourLine(r));
+            // les créneaux libres viennent du registre, le lead les lit au lieu de les calculer (L141)
+            const [slots] = liveLines();
+            if (slots)
+                io.out(slots);
+        }
         return 0;
     }
     // --all balaie les sous-dossiers : il ne lit ni le plan ni le cadence.yaml du dossier courant.
@@ -426,7 +431,10 @@ function dispatch(argv, io) {
                 throw new RafError(`pas de configuration de livraison : ${configPath} (voir « cadence.yaml » dans le README)`);
             const config = parseDeliverConfig(readFileSync(configPath, 'utf8'), configPath);
             const plan = existsSync(planPath) ? loadPlan() : null;
-            const ctx = { root, state: sharedStateDir(root), plan, config, today, dryRun: !!values['dry-run'], sha: values.sha, args: rest, out: io.out, err: io.err };
+            const articles = readDocsConfig(configPath).articles;
+            // Sans public: d'un lot visible, le site reprend le titre de sa Nouveauté la plus récente.
+            const publicTitle = (lot) => lot.public ?? (lot.visible ? loadEntries(newsDir).find((e) => e.lots.includes(lot.id))?.title : undefined);
+            const ctx = { root, state: sharedStateDir(root), plan, config, today, dryRun: !!values['dry-run'], sha: values.sha, args: rest, articles, publicTitle, out: io.out, err: io.err };
             return deliver(ctx, realDeps(root));
         }
         case 'verify': {

package/dist/config.js

@@ -209,12 +209,14 @@ export function readSessionConfig(file) {
     }
     return config;
 }
+const EFFORTS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
+export const EFFORT_STEPS = ['precheck', 'implement', 'fix', 'review', 'ux'];
 const MODELS = ['haiku', 'sonnet', 'opus'];
 const REVIEW_KEYS = ['threshold', 'light', 'full'];
-const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'ux', 'precheck', 'review', 'permissionMode', 'addDirs', 'timeouts'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'ux', 'precheck', 'review', '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, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
+    const config = { precheck: true, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
     if (!existsSync(file))
         return config;
     let raw;
@@ -274,6 +276,17 @@ export function readOrchestrateConfig(file) {
             config.review[k] = m;
         }
     }
+    if (o.effort != null) {
+        if (!isObject(o.effort))
+            throw bad('effort doit être un objet { precheck, implement, fix, review, ux }');
+        for (const [k, v] of Object.entries(o.effort)) {
+            if (!EFFORT_STEPS.includes(k))
+                throw bad(`effort.${k} inconnu (attendu : ${EFFORT_STEPS.join(', ')})`);
+            if (!EFFORTS.includes(v))
+                throw bad(`effort.${k} : ${EFFORTS.join(', ')} attendu`);
+            config.effort[k] = v;
+        }
+    }
     if (o.ux != null) {
         if (typeof o.ux === 'string' && o.ux.trim()) {
             const u = o.ux.trim();
@@ -324,3 +337,69 @@ export function readOrchestrateConfig(file) {
     }
     return config;
 }
+const DOCS_KEYS = ['sync', 'since', 'articles'];
+/** Clé `docs:` de cadence.yaml : `docs.sync`, la documentation qui doit suivre le code. */
+export function readDocsConfig(file) {
+    const none = { sync: [] };
+    if (!existsSync(file))
+        return none;
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const d = raw?.docs;
+    if (d == null)
+        return none;
+    const bad = (what) => new RafError(`${file} : docs.${what}`);
+    if (!isObject(d))
+        throw new RafError(`${file} : docs doit être un objet { sync, since, articles }`);
+    for (const k of Object.keys(d))
+        if (!DOCS_KEYS.includes(k))
+            throw bad(`${k} inconnu (attendu : ${DOCS_KEYS.join(', ')})`);
+    const config = { sync: [] };
+    if (d.since != null) {
+        if (!isDay(d.since))
+            throw bad(`since « ${String(d.since)} » n'est pas une date AAAA-MM-JJ`);
+        config.since = d.since;
+    }
+    if (d.sync != null) {
+        if (!Array.isArray(d.sync))
+            throw bad('sync doit être une liste de { paths, docs }');
+        d.sync.forEach((r, i) => {
+            if (!isObject(r))
+                throw bad(`sync[${i}] doit être un objet { paths, docs }`);
+            for (const k of Object.keys(r))
+                if (k !== 'paths' && k !== 'docs')
+                    throw bad(`sync[${i}].${k} inconnu (attendu : paths, docs)`);
+            const entry = (key) => {
+                const v = list(r[key]);
+                if (!v.length || v.some((x) => !x.trim()))
+                    throw bad(`sync[${i}].${key} : au moins un chemin non vide attendu`);
+                return v.map((x) => x.trim());
+            };
+            config.sync.push({ paths: entry('paths'), docs: entry('docs') });
+        });
+    }
+    if (d.articles != null) {
+        if (!Array.isArray(d.articles))
+            throw bad('articles doit être une liste de { repo, file }');
+        config.articles = d.articles.map((r, i) => {
+            if (!isObject(r))
+                throw bad(`articles[${i}] doit être un objet { repo, file }`);
+            for (const k of Object.keys(r))
+                if (!['repo', 'file', 'name'].includes(k))
+                    throw bad(`articles[${i}].${k} inconnu (attendu : repo, file, name)`);
+            const text = (key) => {
+                const v = r[key];
+                if (typeof v !== 'string' || !v.trim())
+                    throw bad(`articles[${i}].${key} : texte non vide attendu`);
+                return v.trim();
+            };
+            return { repo: text('repo'), file: text('file'), ...(r.name != null ? { name: text('name') } : {}) };
+        });
+    }
+    return config;
+}

package/dist/deliver.js

@@ -5,6 +5,7 @@ import { onTermination, readProcs, SIGNAL_GRACE_MS, TreeTracker } from './proc.j
 import { isPlanOnly } from './audit.js';
 import { headSha, isAncestor, onRemote, readCommits, repoStatus, resolveCommit } from './git.js';
 import { citedRefs } from './link.js';
+import { describeArticle, openArticleLots } from './articles.js';
 import { RafError } from './plan.js';
 import { appendDelivery, lastDelivery, lockAlive, lockFault, lockPath, readLock, releaseLock, removeStaleLock, writeLock } from './state.js';
 const POLL_CI = 15_000;
@@ -235,6 +236,8 @@ export async function deliver(ctx, deps) {
                 out('    (aucune commande)');
             config.deploy.forEach((c, i) => out(`    ${i + 1}. ${c}`));
         }
+        if (ctx.articles?.length)
+            out(`  Articles rafraîchis après une livraison verte (lot « Article <projet> à rafraîchir ») : ${ctx.articles.map(describeArticle).join(', ')}`);
         if (config.verify.length)
             out(`  Vérifications (réessayées pendant ${config.verifyTimeout} s) :`);
         config.verify.forEach((c, i) => out(`    ${i + 1}. ${describeCheck(c, sha)}`));
@@ -285,7 +288,8 @@ export async function deliver(ctx, deps) {
         const head = script === null || !atHead ? sha : (headSha(ctx.root) ?? sha);
         const moved = head !== sha && isAncestor(ctx.root, sha, head);
         const final = moved ? head : sha;
-        const delivered = deliveredLots(ctx, lastDelivery(ctx.state), final);
+        const ids = deliveredIds(ctx, lastDelivery(ctx.state), final);
+        const delivered = deliveredLots(ctx, ids, lastDelivery(ctx.state), final);
         appendDelivery(ctx.state, ctx.today, final);
         if (moved)
             out(`✓ livré : ${final.slice(0, 7)} (tête déplacée par le script depuis ${env.CADENCE_SHORT})`);
@@ -293,6 +297,7 @@ export async function deliver(ctx, deps) {
             out(`✓ livré${config.verify.length ? ' et vérifié' : ''} : ${env.CADENCE_SHORT}`);
         if (delivered)
             out(delivered);
+        refreshArticles(ctx, ids, final);
         return 0;
     }
     finally {
@@ -407,12 +412,10 @@ async function verifyAll(ctx, deps, sha, env) {
  * nommé pour le contexte — les annoncer « livrés » ferait fermer à tort. L'état est celui du départ de
  * la livraison : le plan a été lu avant que le script du projet ne ferme lui-même les lots qu'il livre.
  */
-function deliveredLots(ctx, prev, sha) {
-    if (!ctx.plan || !prev || prev === sha)
-        return null;
-    if (!isAncestor(ctx.root, prev, sha)) {
-        return `livraison précédente (${prev.slice(0, 7)}) hors de l'historique de ${sha.slice(0, 7)} (réécrit ?) : lots livrés non calculés`;
-    }
+/** Lots cités par les commits livrés depuis la livraison précédente ; vide quand elle est inconnue ou hors de l'historique. */
+function deliveredIds(ctx, prev, sha) {
+    if (!ctx.plan || !prev || prev === sha || !isAncestor(ctx.root, prev, sha))
+        return [];
     const lots = ctx.plan.lots();
     const known = new Set((ctx.plan.readonly ? lots.filter((l) => l.status === 'doing') : lots).map((l) => l.id));
     const ids = new Set();
@@ -423,7 +426,51 @@ function deliveredLots(ctx, prev, sha) {
             if (known.has(r.lot))
                 ids.add(r.lot);
     }
-    if (ids.size === 0)
+    return [...ids].sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+}
+function deliveredLots(ctx, ids, prev, sha) {
+    if (!ctx.plan || !prev || prev === sha)
+        return null;
+    if (!isAncestor(ctx.root, prev, sha)) {
+        return `livraison précédente (${prev.slice(0, 7)}) hors de l'historique de ${sha.slice(0, 7)} (réécrit ?) : lots livrés non calculés`;
+    }
+    if (ids.length === 0)
         return null;
-    return `livré : ${[...ids].sort((a, b) => a.localeCompare(b, undefined, { numeric: true })).join(', ')} — ${ctx.plan.readonly ? "à fermer avec l'outil du projet" : 'raf done'} si l'effet est celui attendu`;
+    return `livré : ${ids.join(', ')} — ${ctx.plan.readonly ? "à fermer avec l'outil du projet" : 'raf done'} si l'effet est celui attendu`;
+}
+/**
+ * Livraison verte (L144) : les lots livrés dont le titre est public changent ce que les articles externes racontent, on ouvre
+ * donc le lot qui les rafraîchit. Le plan est écrit mais pas commité (deliver ne commite jamais) ; une erreur ici ne défait pas
+ * une livraison déjà faite.
+ */
+function refreshArticles(ctx, ids, sha) {
+    if (!ctx.plan || !ctx.articles?.length || !ids.length)
+        return;
+    try {
+        // Relu : le script du projet a pu fermer des lots ou commiter le plan depuis le départ de la livraison, save() ne doit pas l'écraser.
+        const plan = ctx.plan.reloaded();
+        const wanted = new Set(ids);
+        const r = openArticleLots({
+            plan,
+            root: ctx.root,
+            rules: ctx.articles,
+            delivered: plan.lots().filter((l) => wanted.has(l.id)),
+            publicTitle: ctx.publicTitle ?? ((l) => l.public),
+            sha,
+            today: ctx.today,
+        });
+        for (const w of r.warnings)
+            ctx.err(`deliver : ${w}`);
+        if (r.opened.length || r.noted.length)
+            plan.save();
+        for (const id of r.opened)
+            ctx.out(`article à rafraîchir : ${id} « ${plan.lot(id).title} » ouvert (plan modifié, à commiter) — à jouer dans une vague ordinaire`);
+        for (const id of r.noted)
+            ctx.out(`article à rafraîchir : ${id} déjà ouvert, titres livrés ajoutés en note (plan modifié, à commiter)`);
+        for (const m of r.manual)
+            ctx.out(`article à rafraîchir : ${m}`);
+    }
+    catch (e) {
+        ctx.err(`deliver : article à rafraîchir non ouvert — ${e.message}`);
+    }
 }

package/dist/docsync.js

@@ -0,0 +1,57 @@
+import { changedFiles } from './git.js';
+/** Motif de chemin : `*` reste dans un dossier, `**` le traverse, `?` un caractère, un `/` final prend tout le dossier ; sinon chemin exact. */
+export function docSyncMatcher(pattern) {
+    const p = pattern.trim().replace(/\\/g, '/').replace(/^\.\//, '');
+    const source = (p.endsWith('/') ? `${p}**` : p)
+        .split(/(\*\*\/?|\*|\?)/)
+        .map((part) => (part === '**/' ? '(?:.*/)?' : part === '**' ? '.*' : part === '*' ? '[^/]*' : part === '?' ? '[^/]' : part.replace(/[.+^${}()|[\]\\]/g, '\\$&')))
+        .join('');
+    const re = new RegExp(`^${source}$`);
+    return (file) => re.test(file);
+}
+/** Liste de motifs : un fichier en fait partie s'il correspond à un motif et à aucun motif « !… » (exclusion, ex. `!**\/*.test.ts`). */
+export function docSyncSet(patterns) {
+    const yes = patterns.filter((p) => !p.startsWith('!')).map(docSyncMatcher);
+    const no = patterns.filter((p) => p.startsWith('!')).map((p) => docSyncMatcher(p.slice(1)));
+    return (file) => yes.some((m) => m(file)) && !no.some((m) => m(file));
+}
+/** Fichiers modifiés par un ensemble de commits, sans doublon. */
+export function filesOf(root, commits) {
+    return new Set(commits.flatMap((c) => changedFiles(root, c.sha)));
+}
+/** Les règles que ces fichiers enfreignent : ils touchent `paths` sans qu'aucun `docs` ne soit parmi eux. */
+export function docSyncGaps(rules, files) {
+    const gaps = [];
+    for (const rule of rules) {
+        if ([...files].some(docSyncSet(rule.docs)))
+            continue;
+        const inPaths = docSyncSet(rule.paths);
+        const touched = [...files].filter(inPaths).sort();
+        if (touched.length)
+            gaps.push({ rule, touched });
+    }
+    return gaps;
+}
+const SHOWN = 5;
+/** `a, b, c, … (+2)` : les premiers fichiers, le reste compté. */
+function listFiles(files) {
+    return files.length <= SHOWN ? files.join(', ') : `${files.slice(0, SHOWN).join(', ')}, … (+${files.length - SHOWN})`;
+}
+/** La ligne de `raf check` et de `cadence lead tour` pour un lot. */
+export function gapMessage(lot, gap) {
+    return `${lot} : documentation en retard — ${listFiles(gap.touched)} sans toucher ${gap.rule.docs.join(' ou ')} (docs.sync)`;
+}
+/**
+ * Consigne du brief de revue (L143) : la liste calculée par le programme, à passer en constat majeur. Vide sans règle
+ * déclarée ; sans écart, une ligne qui dit que le programme a vérifié (le relecteur juge encore le contenu).
+ */
+export function docSyncBrief(rules, gaps) {
+    if (!rules.length)
+        return '';
+    if (!gaps.length)
+        return 'Documentation (cadence.yaml docs.sync): the program checked that the commits of the lot touch the documents their paths call for. Still read the documents themselves against the change.';
+    return [
+        'Documentation (cadence.yaml docs.sync): the program computed that the commits of the lot touch code without touching the document that describes it. Report ONE MAJOR finding per line below, quoting the line, unless the change really leaves the document true (say why then):',
+        ...gaps.map((g) => `- ${listFiles(g.touched)} changed, but none of ${g.rule.docs.join(', ')} was touched`),
+    ].join('\n');
+}

package/dist/orchestrate/briefs.js

@@ -69,7 +69,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 ?? '' }[name];
+        const v = { ...vars, repos: vars.repos ?? '', docs: vars.docs ?? '' }[name];
         if (v === undefined)
             throw new RafError(`gabarit ${FILES[kind]} : valeur manquante pour {{${name}}}`);
         return v;

package/dist/orchestrate/command.js

@@ -10,7 +10,7 @@ import { stopApps } from './app.js';
 import { Plan, RafError, isOpen } from '../plan.js';
 import { AGENTS_DIR } from '../skills.js';
 import { pidAlive, sharedStateDir } from '../state.js';
-import { acquireSlot, cadenceHome, liveSlots, liveWaves, registerWave, unregisterWave, updateWaveRepos } from './registry.js';
+import { acquireSlot, cadenceHome, freeSlots, liveSlots, liveWaves, registerWave, unregisterWave, updateWaveRepos } from './registry.js';
 import { loadTemplates, newsText, objective, renderBrief } from './briefs.js';
 import { Budget, MAX_PASSES, countInterrupted, needsPrecheck } from './cycle.js';
 import { canInstallPrePush, installPrePush, removePrePush, snapshot } from './guard.js';
@@ -137,6 +137,14 @@ function resolveTargets(args, io, refusals) {
 async function trackedDirty(repo) {
     return (await snapshot(repo, { remote: false })).tracked.map((l) => l.slice(3));
 }
+/** `--effort` date de claude 2.1.284 (L137). Une version illisible n'est pas refusée. */
+function olderThanEffort(version) {
+    const m = /(\d+)\.(\d+)\.(\d+)/.exec(version);
+    if (!m)
+        return false;
+    const [a, b, c] = [Number(m[1]), Number(m[2]), Number(m[3])];
+    return a < 2 || (a === 2 && (b < 1 || (b === 1 && c < 284)));
+}
 /** Préconditions : tout ce qui peut être refusé l'est ici, avant d'agir, sans verrou ni écriture. */
 async function preflight(args, targets, io, deps, launch, opts = {}) {
     const refusals = [];
@@ -162,6 +170,10 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
             refusals.push(`${key} : ${e.message}`);
             continue;
         }
+        if (info && olderThanEffort(info.version) && Object.values(env.config.effort).some((e) => e !== 'default')) {
+            refusals.push(`${key} : claude ${info.version} n'a pas --effort (2.1.284 requise) : mettre claude à jour, ou orchestrate.effort à « default » pour chaque passe`);
+            continue;
+        }
         const lot = plan.lots().find((l) => l.id === t.lot);
         if (!lot) {
             refusals.push(`${key} : lot inconnu`);
@@ -283,7 +295,7 @@ function dryRun(lots, io, deps, budget, id) {
             const brief = renderBrief(s.kind, vars, deps.templatesDir);
             writeFileSync(file, brief);
             const playwright = !!mcpServersFor(s.kind, l.visible, '', l.small).playwright;
-            const args = buildArgs({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model, schema: schemaFor(s.kind), agent: s.kind === 'implement' ? undefined : s.kind === 'ux' ? 'ux-reviewer' : s.kind === 'precheck' ? 'precheck-reader' : 'code-reviewer', cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && s.kind === 'implement' ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
+            const args = buildArgs({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model, effort: env.config.effort[s.kind === 'review-small' ? 'review' : s.kind], schema: schemaFor(s.kind), agent: s.kind === 'implement' ? undefined : s.kind === 'ux' ? 'ux-reviewer' : s.kind === 'precheck' ? 'precheck-reader' : 'code-reviewer', cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && s.kind === 'implement' ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
             io.out(`  ${s.kind} : claude ${args.join(' ')}`);
             io.out(`    brief : ${file}`);
             const servers = Object.keys(mcpServersFor(s.kind, l.visible, '', l.small));
@@ -301,14 +313,14 @@ function duration(ms) {
     const s = Math.round(ms / 1000);
     return s < 60 ? `${s} s` : `${Math.floor(s / 60)} min ${String(s % 60).padStart(2, '0')} s`;
 }
-/** Vagues vivantes (toutes, quel que soit leur dossier de départ) et dépôts qu'elles tiennent. */
-function liveLines() {
+/** Vagues vivantes (toutes, quel que soit leur dossier de départ), créneaux libres et dépôts qu'elles tiennent. */
+export function liveLines() {
     const home = cadenceHome();
     const waves = liveWaves(home);
     if (waves.length === 0)
         return [];
     const slots = liveSlots(home).length;
-    const lines = [`vagues en cours : ${waves.length} · sessions en cours : ${slots}`];
+    const lines = [`vagues en cours : ${waves.length} · sessions en cours : ${slots} · créneaux libres : ${freeSlots(waves, DEFAULT_MAX_SESSIONS)} sur ${DEFAULT_MAX_SESSIONS}`];
     for (const w of waves)
         lines.push(`  ${w.wave} (pid ${w.pid}, depuis ${w.started}) lancée depuis ${w.cwd} · plafond ${w.cap ?? '?'} · dépôts : ${w.repos.join(', ')}`);
     return lines;

package/dist/orchestrate/cycle.js

@@ -4,6 +4,8 @@ import { randomUUID } from 'node:crypto';
 import { dirname, join, relative } from 'node:path';
 import { writeFileSync } from 'node:fs';
 import { lotCommits, lotWork } from '../audit.js';
+import { readDocsConfig } from '../config.js';
+import { docSyncBrief, docSyncGaps, filesOf } from '../docsync.js';
 import { readCommits, resolveCommit } from '../git.js';
 import { citedRefs } from '../link.js';
 import { repoShas, repoWork } from '../repos.js';
@@ -198,6 +200,14 @@ function checksText(c) {
     const runs = k.runs.map((r) => `- \`${r.command}\` (${r.label}): ${r.code === 0 ? 'green' : `RED, exit code ${r.code}`}`);
     return [`The program already ran these checks at HEAD ${k.head.slice(0, 7)}, just before this review:`, ...runs, 'Take these results as given: do not rebuild, do not rerun the whole suite, and do not wait on them. Run only a check they do not cover (a targeted test of a case you doubt), and list under "nonVerifie" what neither they nor you verified.'].join('\n');
 }
+/** Consigne docs.sync du brief de revue (L143) : calculée sur les commits du lot au moment de la revue, pas écrite d'avance. */
+function docsText(c) {
+    const plan = c.loadPlan();
+    const { sync } = readDocsConfig(plan.configFile ?? join(c.lot.repo, 'cadence.yaml'));
+    if (!sync.length)
+        return '';
+    return docSyncBrief(sync, docSyncGaps(sync, filesOf(c.lot.repo, lotWork(plan, c.lot.repo, c.lot.lot))));
+}
 /** Gabarit d'une étape : la passe des mineurs et la revue courte qui la suit ont chacune le leur. */
 function briefName(l, kind) {
     if (kind === 'fix' && l.minorFix)
@@ -210,7 +220,7 @@ function briefFor(c, kind) {
     const plan = c.loadPlan();
     const l = c.lot;
     const lot = plan.lot(l.lot);
-    const vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', news: '', captures: '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []) };
+    const vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', 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: '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []) };
     if (l.visible) {
         const pwDir = playwrightDir(c.wave.store.lotDir(l.project, l.lot));
         vars.news = newsText(l.lot, pwDir);
@@ -272,12 +282,13 @@ async function session(c, kind) {
         return overBudget(c);
     const write = kind === 'implement' || kind === 'fix';
     const model = write ? l.model : kind === 'precheck' ? 'sonnet' : reviewModel(c, kind); // le contrôle préalable ne fait que lire : pas d'Opus
+    const effort = c.config.effort[kind === 'review-small' ? 'review' : kind];
     const before = await snapshot(l.repo);
     const neighbours = l.repos ?? [];
     const beforeOthers = await Promise.all(neighbours.map((r) => snapshot(r.path)));
     const n = l.steps.length + 1;
     const sessionId = randomUUID();
-    const step = { n, kind, model, status: 'running', sessionId, started: new Date().toISOString(), headBefore: before.head ?? undefined };
+    const step = { n, kind, model, ...(effort !== 'default' ? { effort } : {}), status: 'running', sessionId, started: new Date().toISOString(), headBefore: before.head ?? undefined };
     l.steps.push(step);
     const label = { implement: 'implementing', fix: 'fixing', review: 'reviewing', ux: 'reviewing', 'review-small': 'reviewing', precheck: 'implementing' };
     transition(c, label[kind]);
@@ -301,6 +312,7 @@ async function session(c, kind) {
         sessionId,
         brief,
         model,
+        effort,
         schema: schemaFor(kind),
         agent: kind === 'ux' ? 'ux-reviewer' : kind === 'precheck' ? 'precheck-reader' : write ? undefined : 'code-reviewer',
         cwd: l.repo,

package/dist/orchestrate/launch.js

@@ -40,8 +40,11 @@ function agentsFor(spec, agents) {
         return agents;
     return { ...agents, [spec.agent]: { ...a, tools: [...a.tools, ...(a.tools.includes(PLAYWRIGHT_TOOLS) ? [] : [PLAYWRIGHT_TOOLS])] } };
 }
+function effortArgs(spec) {
+    return spec.effort && spec.effort !== 'default' ? ['--effort', spec.effort] : [];
+}
 export function buildArgs(spec, agents) {
-    const args = ['-p', spec.brief, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model];
+    const args = ['-p', spec.brief, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model, ...effortArgs(spec)];
     if (spec.agent) {
         if (!agents[spec.agent])
             throw new RafError(`agent introuvable dans le paquet : ${spec.agent}`);
@@ -81,7 +84,7 @@ export function readAgents(dir) {
 export const FORMAT_RETRY_PROMPT = 'Return your report now in the required format (the JSON structure of the schema), exactly as you concluded it. Do not do any further work, do not add anything else.';
 /** Arguments de la relance : même session (--resume), mêmes schéma, modèle, agent (outils restreints), mode de permission, dossiers et interdits. */
 export function buildRetryArgs(spec, sessionId, agents) {
-    const args = ['-p', FORMAT_RETRY_PROMPT, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model];
+    const args = ['-p', FORMAT_RETRY_PROMPT, '--output-format', 'json', '--json-schema', JSON.stringify(spec.schema), '--model', spec.model, ...effortArgs(spec)];
     if (spec.agent) {
         if (!agents[spec.agent])
             throw new RafError(`agent introuvable dans le paquet : ${spec.agent}`);

package/dist/orchestrate/registry.js

@@ -44,6 +44,16 @@ export function liveWaves(home) {
     }
     return out.sort((a, b) => a.started.localeCompare(b.started));
 }
+/**
+ * Les créneaux que le lead peut encore donner à des sous-agents : `total` moins, pour chaque vague vivante, le
+ * plus petit de son plafond et du nombre de dépôts qu'elle tient encore (ses pas prennent un créneau et le
+ * rendent entre deux étapes : les sessions vivantes à l'instant ne disent pas ce que la vague va reprendre).
+ * Une vague sans plafond connu compte pour `total`.
+ */
+export function freeSlots(waves, total) {
+    const held = waves.reduce((n, w) => n + Math.min(w.cap ?? total, w.repos.length), 0);
+    return Math.max(0, total - held);
+}
 /** Inscrit la vague ; écarte au passage les entrées de processus morts (les `.tmp` d'une inscription en cours ne sont pas touchés). */
 export function registerWave(home, given) {
     const w = { ...given, start: given.start ?? processStart(given.pid) ?? undefined };

package/dist/orchestrate/state.js

@@ -53,15 +53,19 @@ export class RunStore {
     static runsDir(launchDir) {
         return join(launchDir, '.cadence', 'runs');
     }
-    /** La dernière vague (par identifiant) ; avec `unfinished`, la dernière qui n'est pas terminée. */
+    /** La dernière vague lancée (par date de lancement : un identifiant libre comme `ol-gains-1` ne se range pas par ordre alphabétique) ; avec `unfinished`, la dernière qui n'est pas terminée. */
     static last(launchDir, opts = {}) {
         const base = RunStore.runsDir(launchDir);
         if (!existsSync(base))
             return null;
-        const ids = readdirSync(base).filter((n) => existsSync(join(base, n, 'wave.json'))).sort().reverse();
-        for (const id of ids) {
-            const store = new RunStore(launchDir, id);
-            if (!opts.unfinished || store.readWave()?.status !== 'done')
+        const stores = readdirSync(base)
+            .filter((n) => existsSync(join(base, n, 'wave.json')))
+            .map((id) => new RunStore(launchDir, id))
+            .map((store) => ({ store, wave: store.readWave() }))
+            // lancement le plus récent d'abord ; à date égale (ou illisible), l'identifiant le plus grand
+            .sort((a, b) => (b.wave?.created ?? '').localeCompare(a.wave?.created ?? '') || b.store.id.localeCompare(a.store.id));
+        for (const { store, wave } of stores) {
+            if (!opts.unfinished || wave?.status !== 'done')
                 return store;
         }
         return null;

package/dist/plan.js

@@ -97,6 +97,10 @@ export class Plan {
             lots.flow = false; // « lots: [] » écrit par init : passer en style bloc
         return new Plan(path, doc, !/^lots:[^\n]*\n(?:#[^\n]*\n)*- /m.test(text), settings);
     }
+    /** Le plan tel qu'il est maintenant sur le disque (un script a pu l'écrire depuis la lecture), mêmes réglages. */
+    reloaded() {
+        return Plan.load(this.path, this.settings);
+    }
     save() {
         this.writable();
         writeFileSync(this.path, this.doc.toString({ lineWidth: 0, indentSeq: this.indentSeq }));
@@ -317,6 +321,13 @@ export class Plan {
         this.doc.get('lots').add(node);
         return id;
     }
+    /** Déclare les dépôts voisins d'un lot (clé `repos:`) : un chemin seul, ou `{ path, cite }` quand le voisin est partagé. */
+    setRepos(lotId, repos) {
+        this.writable();
+        const node = this.doc.createNode(repos.map((r) => (r.cite === undefined ? r.path : { path: r.path, cite: r.cite })));
+        node.flow = true;
+        this.lotNode(lotId).set('repos', node);
+    }
     addTask(lotId, title) {
         this.writable();
         const lot = this.lotNode(lotId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylad/cadence",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "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/skills/lead/SKILL.md

@@ -18,9 +18,9 @@ commands (its CLAUDE.md names them), never with `raf start|done|note|ux|review`.
   (section 2b) count toward this limit: orchestrate sessions plus subagents never exceed two. A wave
   already caps itself (`--max-sessions`, 2 by default, shared by every wave); before starting a
   subagent, check `cadence orchestrate --status`, and while a wave runs, start none beyond the free
-  slots. Count the free slots from what `--status` shows per wave, not from the live sessions (a
-  wave's steps take a slot and give it back between two steps): 2 − Σ min(cap, number of repositories
-  of the wave that still have lots). Never raise `--max-sessions` above two to speed a wave up.
+  slots. Read the free slots, do not compute them: `cadence orchestrate --status` and `cadence lead tour` print
+  `créneaux libres : N sur 2` (the registry subtracts, for each live wave, min(cap, repositories it still holds)
+  from the two slots; no line from `lead tour` means no live wave, so both are free). Never raise `--max-sessions` above two to speed a wave up.
 - **Never two subagents in the same repository at the same time**, and the lead does not commit in a
   repository where a subagent is working.
 - **Deliveries and `raf ux` / `raf review` verdicts are done by the lead, one project at a time** —

package/templates/orchestrate/review-small.md

@@ -5,6 +5,7 @@ cite the lot (`raf commits {{lot}}`, or `git log`), run the checks, report real
 {{repos}}
 {{ux}}
 {{checks}}
+{{docs}}
 {{choix}}
 A proposed sub-task describes an observable bug (a wrong output, a crash, a measured regression); any other minor finding stays a note of this lot, not a sub-task.
 You are read-only: do not modify, commit, push or run `raf review|ux|done`. Do not launch subagents.

package/templates/orchestrate/review.md

@@ -3,6 +3,7 @@ You are given the repository path and the lot id only: read the diff yourself fr
 cite the lot (`raf commits {{lot}}`, or `git log`), run the checks, report real defects only.
 {{repos}}
 {{checks}}
+{{docs}}
 {{choix}}
 A proposed sub-task describes an observable bug (a wrong output, a crash, a measured regression); any other minor finding stays a note of this lot, not a sub-task.
 You are read-only: do not modify, commit, push or run `raf review|ux|done`. Do not launch subagents.