@sylad/cadence 0.21.0 → 0.23.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.21.0",
+      "version": "0.23.0",
       "source": "./",
       "author": {
         "name": "Sylvain Ladoire"
@@ -16,8 +16,8 @@
     },
     {
       "name": "cadence-hud",
-      "description": "A status band above the Claude Code prompt: context, 5 h / 7 d quota windows, cost per model, agents of the session and the running cadence orchestrate waves. No CLI needed.",
-      "version": "0.3.4",
+      "description": "A status band above the Claude Code prompt: context, 5 h / 7 d quota windows, cost per model, agents of the session and the running cadence orchestrate waves. Works without the cadence CLI, except the per-project plan progress, which needs `cadence` on the PATH.",
+      "version": "0.4.1",
       "source": "./plugins/cadence-hud",
       "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.21.0",
+  "version": "0.23.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.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
+**0.23.0**: the progress bar of each project in the `cadence-hud` band is coloured by the share of lots done, red below 33 %, orange below 66 %, green beyond (L152, `cadence-hud` 0.4.1); `cadence deliver` under a wave lock refuses only when a lot of the wave still works in that very repository, a linked worktree included (L127). **0.22.0**: `cadence orchestrate --continue` draws the next ready lot of the plan itself, in the declared priority, until the budget, the time window or a question stops it (L147); `cadence session context` prints the context of the session, which the `cadence-hud` band publishes, and the `lead` skill chains lots without the human while it stays under 60 % (L148); the band shows the progress of each project's plan, and `cadence lead tour --json` gains `progress` (L149, `cadence-hud` 0.4.0); the final review of a lot is always played, the lot's own budget bounding the writing passes only, with 65 k tokens reserved for it (L145); the cause « tests rouges après … » names the pass whose tests were red (L151). **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),
@@ -481,6 +481,11 @@ cadence session close --all --depth 2   # sub-folder holding a plan (--depth n:
                                    # exit = the worst code of the projects (2 error, 1 open, 0 closed)
 cadence session next "finish L3" "review L4"    # shown by the next session start; replaces the previous notes
 cadence session next --clear       # erase those notes, on purpose
+cadence session context            # `ctx 42 % (84000/200000)`: the context of YOUR session, as the cadence-hud band publishes
+                                   # it: the one named by $CLAUDE_CODE_SESSION_ID (set in Claude Code's Bash); --session <id>
+                                   # overrides it; with no variable, the folder decides only if a single session publishes for it
+                                   # (two sessions in one folder = exit 2, "pass --session"); exit 2 too when no fresh figure
+                                   # (band not loaded) = treat as at the threshold
 ```
 
 `session start` records its time in the worktree's state (`session.json`, under the git dir); the next
@@ -591,7 +596,13 @@ beta · en cours rien · dérive aucune · notes : aucune · prochain T2 Second
 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
+`next`, `repo`, and `error` when the project could not be read), plus `progress` — `{ done, doing, todo, added7 }`,
+the lots done / in progress / to do (dropped and recurring lots left out) and those created in the last 7 days (L149), which
+[`cadence-hud`](plugins/cadence-hud/README.md) draws as one progress bar per project. Projects come in the order of the
+`priority:` key of the folder's `cadence.yaml` (the one `orchestrate --continue` reads), the others after, alphabetically; an unreadable `cadence.yaml` or
+a `priority:` that is not a list of names (`priority: ol`, `priority: []`) keeps the alphabetical order and adds a first row `cadence.yaml · ✗ erreur : <cause>` (`project: "cadence.yaml"` with `error` in `--json`).
+"Created in the last 7 days" means today and the six days before. When the folder has no sub-project but is itself a project, the tour is that project's single line
+(this is what `cadence-hud` asks from a session opened inside a project). The tour is read-only: it changes
 no plan. It exits 0 even when a project is in error — that project's line reads
 `beta · ✗ erreur : <cause>`. The `lead` skill runs it instead of one subagent per project.
 
@@ -813,11 +824,40 @@ cadence orchestrate maritime-atlas:Q4/accueil-4-ux12@haiku   # a lot id may cont
 cadence orchestrate … --budget 1.5M          # 1500000, 1.5M, 800k; default 2M
 cadence orchestrate … --max-sessions 3       # sessions running at the same moment, all waves together; default 2
 cadence orchestrate … --dry-run              # preconditions + the plan of the wave; nothing is started
+cadence orchestrate --continue [--until 18:00] [--priority cadence,maritime]   # the wave draws the next ready lot itself (below)
 cadence orchestrate --status [<wave>]        # the live waves and the repositories they hold, then the table (default: the last wave of this folder)
 cadence orchestrate --status [<wave>] --watch [--interval 10]   # the same, redrawn every 10 s (--interval in seconds); stops by itself when no wave is running (with an explicit `<wave>`: when that wave is no longer running)
 cadence orchestrate --resume [<wave>] [--budget 1M] [--answer ol-companion:L22 "reply"]
 ```
 
+**`--continue` — idle time (L147)**: lots given on the command line open the wave (none: the first ones are drawn from the
+plan too); then, each time the lots in play are finished, the wave **draws the next ready lots of the plan** — up to the
+session cap — and plays them in the same wave (same budget, same state folder, journal line `continue : tire …`). A lot
+is drawn when it is `todo`, its `after` is lifted, it is not recurring, neither its title nor a note says « à décider »
+(« à décider avec … », « (à décider) »: a lot waiting for a human decision), it is not already in the wave, and its own budget (derived from its estimate)
+fits in the budget left — otherwise the next one that fits is taken (a lot that does not fit in what is left of the current
+round is not dropped: it is tried again at the next round, once the budget allows it). A round takes at most **one lot per
+repository** while other repositories have ready lots — the pool plays the lots of one repository one after the other, so a
+second one would leave a session idle — and is completed with the same repository when nothing else is ready. Projects are visited in the declared **priority**:
+`--priority cadence,maritime`, or a `priority: [cadence, maritime]` list in the `cadence.yaml` of the folder you launch from
+(the parent of the projects); a name also covers `name-…` (`maritime` → `maritime-atlas`), the other projects come after, in
+alphabetical order. Launched from inside a project, only that project is drawn. A `priority:` key that cannot be read is refused before anything
+starts, lots given or not. A candidate that preflight refuses (dirty tree, Node missing…) is skipped with its cause in the
+journal (`continue : lot sauté — <cause>`; for the first draw also on the error output). Drawing stops — `continue : arrêt — <reason>` — at: the budget, the
+time window (`--until HH:MM`, today's clock: nothing new is drawn from then on, a running lot is not cut), the usage limit,
+a question asked (the wave stays resumable with `--answer`), two lots handed back in a row, an interrupted wave, or no ready
+lot whose estimate fits the budget left. `--resume … --continue` draws again after the resumed lots. `--dry-run --continue` replays the
+draws round by round with the same function as the wave (one lot per repository per round, pre-check, budget counted on the estimates) and
+names the candidates skipped with their cause: `tour 1 : a:L2, b:L2 · tour 2 : a:L3, a:L4`. Drawing happens between rounds: a round of up to `--max-sessions` lots must finish before the next draw.
+
+**Chaining without the human (L148)**: the `lead` skill, once the human has chosen the first lots and the order, does not ask « next? »
+after a lot that comes back ready: it re-verifies it, records `raf done`, pushes, delivers, has the `qa-reviewer` check the
+delivered app, then starts the next wave with `--continue`, in the declared priority — one project at a time, within the two-session
+limit. Before each new wave it reads the context of its own session with `cadence session context` (the figure of the `ctx` segment of the `cadence-hud` band, which publishes the context of each session to `~/.cadence/orchestrate/hud-context/<session id>.json`; the command picks the file named by `$CLAUDE_CODE_SESSION_ID`, set in the environment of the session's Bash, never "the latest file of the folder" — two sessions of one folder alternate; without the band loaded in that session the command exits with code 2, and a missing or stale figure counts as at the threshold); from
+**60 %** upward it starts nothing: it runs `session-close` in each project touched, writes its memory and records three lines for next
+time (`cadence session next`). Stays with the human: the first choice and the order, the questions a session raised, the UX
+reservations; a lot that is not ready, a red delivery or a blocking QA finding is reported and not chained over.
+
 **Lot ids containing `/` (L120)**: the first `:` separates the project from the lot, a final `@` the model, and the lot
 keeps its `/` (`maritime-atlas:Q4/accueil-4-ux12@haiku`); this holds for `--dry-run`, `--status`, `--resume` and
 `--answer` too. In `.cadence/runs/<wave>/` the `/` of the lot becomes `__` (`maritime-atlas--Q4__accueil-4-ux12.json`,
@@ -987,7 +1027,7 @@ cours`; the lock of a dead process is detected and cleared); two waves on differ
 side, even when started from the same parent folder. A repository is released **as soon as every lot of the wave that
 touches it is finished** (ready, handed back or failed): its lock and its `pre-push` guard are lifted while the wave goes
 on elsewhere, so `cadence deliver` accepts it (a repository with a lot still to play, a question or a suspended lot stays
-held until the wave ends). They share a **cap on simultaneous sessions**, counted
+held until the wave ends). `cadence deliver` also reads the wave's own state when a lock is still held: it refuses only if the wave still has a lot running, queued or suspended **in this repository**, and goes ahead when the lots left are elsewhere (an unreadable wave state still refuses). They share a **cap on simultaneous sessions**, counted
 across all live waves: 2 by default, `--max-sessions N` (or `CADENCE_MAX_SESSIONS=N`) to change it — give
 every wave the same value: each wave counts ALL live sessions, whatever their slot, and waits while that
 count has reached ITS OWN cap, so with different caps the highest one can push the total past the lowest
@@ -1010,8 +1050,14 @@ tree (screenshots left at the root, a commit) is an incident of that lot only: t
 
 **Budget**: the wave counts input + cache writes + output tokens (default 2 M); cache reads are kept and
 shown apart. Each lot also has its own budget derived from its estimate (400 k tokens per day, floor 200 k, shown by
-`--dry-run`): a lot that spent it gets no further session and is handed back to the lead, the wave budget stays for
-the others. When the budget (or the usage limit) is reached no new session starts, the running ones
+`--dry-run`): it bounds the *writing* passes, never the reviews. A lot that spent it gets no further implementation or
+fix and is handed back to the lead, but its review (and UX review) is played first; a fix pass starts only if
+the remaining budget can also pay the review that follows it (65 k tokens reserved: a fixed amount close to the 90th
+percentile of the full reviews, 62.7 k over 187 reviews; the short review after the minors pass has a higher p90, 67.6 k
+over 114; measured on 2026-10-09 in the wave journals `.cadence/runs`, `tokens.counted`, 67 waves from 10-04 to 10-09).
+Exception: when the tests are red after a write pass, the lot goes to a fix pass without a review; if that fix pass is
+refused for lack of budget the lot is handed back to the lead without a review, with its findings, and the cause names
+the red tests: the pass it names is the one whose tests were red, counted by its number (« la passe fix 2 », « l'implémentation »), and « la passe des mineurs » appears only when that pass was the one played. The wave budget stays for the others. When the budget (or the usage limit) is reached no new session starts, the running ones
 finish, the wave is *suspended* (exit code 3) and `--resume --budget …` continues. A session that returns
 nothing readable, times out (45 min for work, 25 for a review) or fails is not retried; the lot is handed
 back with the cause. Exit codes: 0 every lot ready · 1 at least one lot handed back (question, failure,
@@ -1217,7 +1263,19 @@ after it ended, then disappears. A background command counted for more than an h
 record of when it started, is no longer shown as running: it moves to a grey `N cmd sans fin
 vue` ("end never seen") right after `N cmd`, because its end notification may never have reached
 the session. Waves are read from disk (`~/.cadence/orchestrate/waves/`, then `.cadence/runs/`); no
-cadence command is run, and the CLI is not required.
+cadence command is run, and the CLI is not required for those. One more block needs it: the **progress of the plans**,
+one line per active project (a project with open lots), in the order of `priority:`:
+
+```
+ol      ▮▮▮▮▮▯▯▯▯▯ 39/78 · 0 en cours · +3 cette semaine
+cadence ▮▮▮▮▮▯▯▯▯▯ 10/20 · 2 en cours
+```
+
+The bar is lots done over lots done + in progress + to do (dropped and recurring lots left out);
+`+N cette semaine` counts the lots created in the last 7 days (today and the six before) and is left out at zero. The source is
+`cadence lead tour <folder> --json` (the folder a wave was launched from, otherwise the session's: a folder of projects gives one line per project, a project with no sub-project gives its own single line),
+read again at every wave transition and otherwise every minute; without `cadence` on the PATH, the
+lines are simply not drawn.
 
 Install it as a plugin from the same marketplace:
 
@@ -1228,7 +1286,8 @@ Install it as a plugin from the same marketplace:
 
 `/hud` hides or shows the band. `/hud cmd` lists the background commands being counted (id, tool,
 origin `session` or `agent <id>`, age, name; `(sans fin vue)` on the ones above). Any other argument
-answers `argument inconnu : … (attendu : cmd)` and leaves the band as it is. The source lives in [`plugins/cadence-hud`](plugins/cadence-hud/README.md)
+`/hud projets` folds the project list to one line, and opens it again. Any other argument
+answers `argument inconnu : … (attendu : cmd, projets)` and leaves the band as it is. The source lives in [`plugins/cadence-hud`](plugins/cadence-hud/README.md)
 (its own README has the details of every cell); it is not part of the npm package. To work on it:
 `claude plugin validate plugins/cadence-hud`, `claude plugin test plugins/cadence-hud`, and
 `tsc -p plugins/cadence-hud` once Claude Code has loaded the plugin at least once (it generates

package/bin/cadence.js

@@ -29,6 +29,7 @@ if (tool === 'raf') {
   cadence session start|close --all [--depth 1]   depuis un dossier non dépôt : une section par projet des sous-dossiers
   cadence session next "ligne" …       notes pour la prochaine session (remplacent les précédentes)
   cadence session next --clear         efface ces notes ; sans ligne ni --clear, la commande refuse
+  cadence session context [--session <id>]   contexte de la session (variable CLAUDE_CODE_SESSION_ID, sinon la seule du dossier) publié par la bande cadence-hud ; code 2 sans chiffre frais
   cadence deliver [--dry-run] [--sha rév] [--config cadence.yaml] [-- arguments du script du projet]
                     CI du sha poussé → déploiement → vérifications de l'effet ;
                     ou le script de livraison du projet (deliver.script), sous verrou et journal
@@ -38,8 +39,10 @@ if (tool === 'raf') {
   cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--max-sessions 2] [--wave id] [--dry-run]
                     une session claude neuve par étape (implémentation, revues, corrections) ; --status, --resume ;
                     --max-sessions : sessions simultanées, toutes vagues confondues (CADENCE_MAX_SESSIONS)
+                    --continue [--until HH:MM] [--priority a,b] : tire seul les lots prêts du plan, jusqu'à une borne
   cadence lead tour [dossier] [--idle 3] [--json]
-                    le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan
+                    le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan, ou la ligne du dossier courant
+                    s'il est lui-même un projet ; une première ligne « cadence.yaml · ✗ erreur » si priority: est illisible
   cadence skills install [--dir .claude] [--force]
                     installe les skills Claude Code session-start, session-close, deliver et l'agent ux-reviewer`);
   process.exitCode = !tool || ['help', '--help', '-h'].includes(tool) ? 0 : 2;

package/dist/cli.js

@@ -20,6 +20,8 @@ import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.j
 import { findProjects, leadTour, tourLine } from './lead.js';
 import { liveLines, orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
 import { activeLock, REPO_LOCK } from './orchestrate/lock.js';
+import { cadenceHome, openLotsIn } from './orchestrate/registry.js';
+import { readHudContext } from './hud-context.js';
 import { sessionClose, sessionStart } from './session.js';
 import { clearNext, readNext, sharedStateDir, stateDir, writeNext } from './state.js';
 const HELP = `raf — plan « reste à faire » versionné dans le dépôt, relié aux commits
@@ -42,8 +44,8 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf ignore <sha> | "<sujet exact>" [--reason texte]   acquitte un commit sans lot (ou citant un id inconnu) sans réécrire l'historique ; raf check --ignored les liste
   raf gantt [-o docs/plan/gantt.html]
   raf hook install      (pre-commit et post-commit ; cadence.yaml hook.autostart: warn|refuse|start)
-  cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--dry-run] [--wave nom]   une session claude neuve par étape ; --status [vague] [--watch [--interval s]] ; --resume [vague] [--budget 1M] [--answer projet:lot "réponse"]
-  cadence lead tour [dossier] [--idle 3] [--json]   le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan (en cours, dérive, notes de clôture, prochain lot prêt, dépôt)
+  cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--dry-run] [--wave nom] [--continue [--until HH:MM] [--priority a,b]]   une session claude neuve par étape ; --status [vague] [--watch [--interval s]] ; --resume [vague] [--budget 1M] [--answer projet:lot "réponse"]
+  cadence lead tour [dossier] [--idle 3] [--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)
   cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
   raf news new <lot…> [--title t] | list | check | stamp | build [-o dossier]   (aussi « cadence news … »)
 
@@ -115,6 +117,7 @@ function dispatch(argv, io) {
             status: { type: 'string' },
             since: { type: 'string' },
             idle: { type: 'string' },
+            session: { type: 'string' },
             all: { type: 'boolean' },
             depth: { type: 'string' },
             output: { type: 'string', short: 'o' },
@@ -140,7 +143,7 @@ function dispatch(argv, io) {
     if (!isDay(today))
         throw new RafError(`RAF_TODAY invalide : ${today} (attendu AAAA-MM-JJ)`);
     const root = gitRoot(io.cwd) ?? io.cwd;
-    // Le tour parcourt les sous-dossiers : il ne lit ni le plan ni le cadence.yaml du dossier courant.
+    // Le tour parcourt les sous-dossiers (ou, sans sous-projet, prend le dossier lui-même s'il est un projet) : il ne lit pas le plan du dossier courant.
     if (command === 'lead') {
         if (rest[0] !== 'tour' || rest.length > 2)
             throw new RafError('usage : cadence lead tour [dossier] [--idle 3] [--json]');
@@ -406,6 +409,9 @@ function dispatch(argv, io) {
             throw new RafError('usage : raf hook install|pre-commit|post-commit');
         }
         case 'session': {
+            // Le contexte de la session ne dépend d'aucun dépôt : le lead le lit depuis le dossier parent.
+            if (rest[0] === 'context')
+                return sessionContext(io, values.session);
             if (!gitRoot(io.cwd))
                 throw new RafError('session : à lancer dans un dépôt git');
             // « next » n'écrit que les notes : la commande du projet ne se joue qu'à la reprise et à la clôture.
@@ -425,7 +431,9 @@ function dispatch(argv, io) {
             if (!gitRoot(io.cwd))
                 throw new RafError('deliver : à lancer dans un dépôt git');
             const orchestrating = activeLock(join(sharedStateDir(root), REPO_LOCK));
-            if (orchestrating)
+            // La vague tient le verrou jusqu'à la fin de ses lots ; ne refuse que si l'un d'eux travaille encore dans CE dépôt (état illisible : on refuse).
+            const stillOpen = orchestrating ? openLotsIn(cadenceHome(), orchestrating.pid, root) : null;
+            if (orchestrating && (stillOpen === null || stillOpen.length > 0))
                 throw new RafError(`deliver : orchestration en cours (vague ${orchestrating.wave}, pid ${orchestrating.pid}) — livrer une fois les lots de ce dépôt finis (le verrou tombe dès que tous sont prêts ou rendus)`);
             if (!existsSync(configPath))
                 throw new RafError(`pas de configuration de livraison : ${configPath} (voir « cadence.yaml » dans le README)`);
@@ -772,6 +780,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 ». */
+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})`);
+    return 0;
+}
 function session([sub, ...args], ctx, values) {
     switch (sub) {
         case 'start': {
@@ -806,6 +822,6 @@ function session([sub, ...args], ctx, values) {
             return 0;
         }
         default:
-            throw new RafError('usage : cadence session start [--since …] [--idle 2] | close [--since …] | start|close --all [--depth n] | next "ligne" … | next --clear');
+            throw new RafError('usage : cadence session start [--since …] [--idle 2] | close [--since …] | start|close --all [--depth n] | next "ligne" … | next --clear | context [--session id]');
     }
 }

package/dist/config.js

@@ -3,7 +3,7 @@ import { basename, dirname, isAbsolute, join, posix, relative, resolve } from 'n
 import { parse } from 'yaml';
 import { isDay } from './dates.js';
 import { gitRoot } from './git.js';
-import { FIELDS, RafError, STATUSES } from './plan.js';
+import { FIELDS, Plan, RafError, STATUSES } from './plan.js';
 const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates'];
 const FORMAT_KEYS = ['lots', 'fields', 'statuses', 'estimates'];
 const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
@@ -89,6 +89,16 @@ export function readPlanConfig(file, root) {
         throw bad('path est vide');
     return { ...(p.path != null ? { path: String(p.path) } : {}), settings };
 }
+/**
+ * Le chargeur du plan du projet dont `root` est la racine : le `cadence.yaml` est lu tout de suite (une erreur sort ici), le plan à
+ * chaque appel. Une seule lecture de « où est le plan et comment le lire » pour l'orchestrateur, `lead tour` et le tirage de `--continue`.
+ */
+export function planLoader(root) {
+    const configPath = join(root, 'cadence.yaml');
+    const planConfig = readPlanConfig(configPath, root);
+    const planPath = resolve(root, planConfig?.path ?? 'docs/plan/raf.yaml');
+    return () => Plan.load(planPath, { ...planConfig?.settings, config: configPath });
+}
 function parseFormat(p, bad) {
     const format = { lots: p.lots == null ? 'lots' : String(p.lots), fields: {}, statuses: {}, estimates: {} };
     for (const key of ['fields', 'statuses', 'estimates'])

package/dist/hud-context.js

@@ -0,0 +1,117 @@
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync, unlinkSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { cadenceHome } from './orchestrate/registry.js';
+/** Au-delà, le chiffre écrit par la bande est trop vieux pour guider un arrêt (la bande le rafraîchit toutes les 5 s). */
+export const HUD_CONTEXT_MAX_AGE_MS = 120_000;
+/** Un fichier de session plus vieux que cela est ignoré et supprimé à la lecture (une session fermée ne le rafraîchit plus). */
+export const HUD_CONTEXT_PURGE_MS = 24 * 3600_000;
+/** Dossier où la bande cadence-hud publie le contexte de chaque session : un fichier `<id de session>.json` par session. */
+export function hudContextDir(env = process.env) {
+    return join(cadenceHome(env), 'hud-context');
+}
+/** Le nom de fichier d'une session : le même nettoyage que le script d'écriture de la bande (lettres, chiffres, `-`, `_`). */
+export function hudContextFile(session) {
+    return `${session.replace(/[^A-Za-z0-9_-]/g, '_')}.json`;
+}
+function sameFolder(a, b) {
+    const real = (p) => {
+        try {
+            return realpathSync(p);
+        }
+        catch {
+            return resolve(p);
+        }
+    };
+    return real(a) === real(b);
+}
+const isNum = (n) => typeof n === 'number' && Number.isFinite(n);
+/** Retire les fichiers de plus de 24 h (selon `at`, ou la date du fichier quand `at` manque) ; rend les autres. */
+function livingFiles(dir, nowMs) {
+    const kept = [];
+    for (const name of readdirSync(dir)) {
+        if (!name.endsWith('.json'))
+            continue;
+        const file = join(dir, name);
+        let at;
+        try {
+            const raw = JSON.parse(readFileSync(file, 'utf8'));
+            if (isNum(raw?.at))
+                at = raw.at;
+        }
+        catch {
+            /* illisible : l'âge du fichier décide */
+        }
+        try {
+            at ??= statSync(file).mtimeMs;
+            if (nowMs - at > HUD_CONTEXT_PURGE_MS) {
+                unlinkSync(file);
+                continue;
+            }
+        }
+        catch {
+            continue;
+        }
+        kept.push(file);
+    }
+    return kept;
+}
+/** La variable que Claude Code pose dans l'environnement de ses commandes Bash : l'id de la session, nom du fichier que la bande écrit. */
+export const SESSION_ID_ENV = 'CLAUDE_CODE_SESSION_ID';
+/**
+ * Le contexte publié par la bande pour la session de l'appelant, dans l'ordre : `session` quand on la désigne, sinon la session de la
+ * variable `CLAUDE_CODE_SESSION_ID` ; seulement si elle est absente ET qu'un seul fichier publie pour `cwd`, celui-là (deux sessions
+ * d'un même dossier alternent : « la plus récente » donnerait le chiffre de l'autre, d'où le refus). Sinon une raison de ne pas le croire
+ * (aucune session, plusieurs, illisible, incomplet, périmé).
+ */
+export function readHudContext(env, nowMs, target) {
+    const dir = hudContextDir(env);
+    if (!existsSync(dir))
+        return { ok: false, reason: `${dir} absent (le mod cadence-hud est-il chargé ?)` };
+    const files = livingFiles(dir, nowMs);
+    let file;
+    let unreadable = 0;
+    const fromEnv = target.session === undefined && !!env[SESSION_ID_ENV];
+    const session = target.session ?? (env[SESSION_ID_ENV] || undefined);
+    if (session !== undefined) {
+        file = join(dir, hudContextFile(session));
+        if (!files.includes(file))
+            return { ok: false, reason: `aucun contexte publié pour la session ${session}${fromEnv ? ` (variable ${SESSION_ID_ENV})` : ''} (${file} absent ; le mod cadence-hud est-il chargé dans cette session ?)` };
+    }
+    else {
+        const found = [];
+        for (const f of files) {
+            try {
+                const raw = JSON.parse(readFileSync(f, 'utf8'));
+                if (typeof raw?.cwd === 'string' && sameFolder(raw.cwd, target.cwd))
+                    found.push({ file: f, at: isNum(raw.at) ? raw.at : -Infinity });
+            }
+            catch {
+                unreadable++;
+            }
+        }
+        // Un fichier périmé est une session close ou muette, pas une rivale : elle ne compte parmi les candidates que si aucune n'est fraîche.
+        const fresh = found.filter((c) => nowMs - c.at <= HUD_CONTEXT_MAX_AGE_MS);
+        const candidates = (fresh.length ? fresh : found).map((c) => c.file);
+        if (candidates.length > 1)
+            return { ok: false, reason: `plusieurs sessions dans ce dossier (${candidates.map((f) => basename(f, '.json')).join(', ')}) et ${SESSION_ID_ENV} absente : passer --session <id>` };
+        file = candidates[0];
+        if (!file) {
+            const more = unreadable ? ` ; ${unreadable} fichier(s) illisible(s)` : '';
+            return { ok: false, reason: `aucune session de la bande ne publie pour ${target.cwd} dans ${dir} (le mod cadence-hud est-il chargé dans cette session ?)${more}` };
+        }
+    }
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return { ok: false, reason: `${file} illisible` };
+    }
+    const { cwd, percent, tokens, window, at } = raw;
+    if (typeof cwd !== 'string' || ![percent, tokens, window, at].every(isNum))
+        return { ok: false, reason: `${file} incomplet` };
+    const age = nowMs - at;
+    if (age > HUD_CONTEXT_MAX_AGE_MS)
+        return { ok: false, reason: `${file} périmé (${Math.round(age / 1000)} s)` };
+    return { ok: true, ctx: { cwd, percent: percent, tokens: tokens, window: window, at: at } };
+}

package/dist/lead.js

@@ -1,23 +1,25 @@
 import { existsSync, readdirSync, statSync } from 'node:fs';
-import { basename, join, resolve } from 'node:path';
+import { basename, join } from 'node:path';
 import { audit, nextUp, planCommits } from './audit.js';
-import { readPlanConfig } from './config.js';
+import { planLoader, readPlanConfig } from './config.js';
 import { diffDays } from './dates.js';
 import { gitRoot, repoStatus } from './git.js';
 import { linkCommits } from './link.js';
-import { Plan } from './plan.js';
 import { lastActivity, lockStatus } from './session.js';
+import { priorityRank, readPriority } from './orchestrate/continue.js';
 import { readNext, sharedStateDir, stateDir } from './state.js';
 export const NOTES_MAX = 120;
 export const TITLE_MAX = 60;
 /** Au-delà de ce nombre de jours sans activité, un lot en cours est dit silencieux. */
 export const TOUR_IDLE = 3;
-const empty = (project) => ({ project, doing: [], drift: [], notes: [], next: null, repo: [] });
+/** Un lot créé depuis moins de ce nombre de jours (aujourd'hui compris : 0 à 6 jours d'écart) compte parmi les « ajoutés cette semaine ». */
+export const ADDED_DAYS = 7;
+const empty = (project) => ({ project, doing: [], drift: [], notes: [], next: null, progress: { done: 0, doing: 0, todo: 0, added7: 0 }, repo: [] });
 export function truncate(text, max) {
     return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
 /** Un dossier est un projet s'il porte docs/plan/raf.yaml, ou un cadence.yaml avec `plan:`. */
-function isProject(dir) {
+export function isProject(dir) {
     if (existsSync(join(dir, 'docs/plan/raf.yaml')))
         return true;
     const conf = join(dir, 'cadence.yaml');
@@ -58,10 +60,7 @@ export function tourRow(dir, today, idle = TOUR_IDLE) {
     const row = empty(basename(dir));
     try {
         const root = gitRoot(dir) ?? dir;
-        const configPath = join(root, 'cadence.yaml');
-        const planConfig = readPlanConfig(configPath, root);
-        const planPath = resolve(root, planConfig?.path ?? 'docs/plan/raf.yaml');
-        const plan = Plan.load(planPath, { ...planConfig?.settings, config: configPath });
+        const plan = planLoader(root)();
         const lots = plan.lots();
         const all = linkCommits(lots, planCommits(plan, root), plan.refs);
         const { doing, ready } = nextUp(lots);
@@ -74,6 +73,13 @@ export function tourRow(dir, today, idle = TOUR_IDLE) {
         });
         row.drift = audit(plan, root, join(root, 'docs/nouveautes'), today).map((i) => `${i.warning ? '⚠' : '✗'} ${i.message}`);
         row.notes = readNext(stateDir(root))?.lines ?? [];
+        const counted = lots.filter((l) => l.status !== 'dropped' && l.every === undefined);
+        row.progress = {
+            done: counted.filter((l) => l.status === 'done').length,
+            doing: counted.filter((l) => l.status === 'doing').length,
+            todo: counted.filter((l) => l.status === 'todo').length,
+            added7: counted.filter((l) => l.created !== undefined && diffDays(l.created, today) >= 0 && diffDays(l.created, today) < ADDED_DAYS).length,
+        };
         row.next = ready[0] ? { id: ready[0].id, title: ready[0].title } : null;
         const s = repoStatus(root);
         if (s.dirty || s.untracked)
@@ -88,8 +94,26 @@ export function tourRow(dir, today, idle = TOUR_IDLE) {
     }
     return row;
 }
+/**
+ * Les projets rangés par la clé `priority:` du cadence.yaml du dossier (L149) ; les autres après, par ordre alphabétique.
+ * Une priorité illisible ou invalide ne vide pas le tableau : l'ordre alphabétique reste, et une première ligne `cadence.yaml` en erreur le dit.
+ * Un dossier qui n'a aucun sous-projet mais est lui-même un projet donne la ligne de ce projet seul (la bande l'interroge depuis le dossier de la session).
+ */
 export function leadTour(parent, today, idle = TOUR_IDLE) {
-    return findProjects(parent).map((dir) => tourRow(dir, today, idle));
+    const dirs = findProjects(parent);
+    if (dirs.length === 0 && isProject(parent))
+        return [tourRow(parent, today, idle)];
+    const rows = dirs.map((dir) => tourRow(dir, today, idle));
+    let priority = [];
+    let problem;
+    try {
+        priority = readPriority(parent);
+    }
+    catch (e) {
+        problem = { ...empty('cadence.yaml'), error: (e instanceof Error ? e.message : String(e)).split('\n')[0] };
+    }
+    const sorted = rows.map((r, i) => ({ r, i })).sort((a, b) => priorityRank(a.r.project, priority) - priorityRank(b.r.project, priority) || a.i - b.i).map((x) => x.r);
+    return problem ? [problem, ...sorted] : sorted;
 }
 const DRIFT_SHOWN = 2;
 /** Une ligne par projet : projet · en cours · dérive · notes · prochain lot prêt · dépôt. */

package/dist/orchestrate/command.js

@@ -2,16 +2,17 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
-import { readOrchestrateConfig, readPlanConfig } from '../config.js';
+import { planLoader, readOrchestrateConfig } from '../config.js';
 import { isDay, toDay } from '../dates.js';
 import { gitRoot } from '../git.js';
 import { onTermination } from '../proc.js';
 import { stopApps } from './app.js';
-import { Plan, RafError, isOpen } from '../plan.js';
+import { RafError, isOpen } from '../plan.js';
 import { AGENTS_DIR } from '../skills.js';
 import { pidAlive, sharedStateDir } from '../state.js';
 import { acquireSlot, cadenceHome, freeSlots, liveSlots, liveWaves, registerWave, unregisterWave, updateWaveRepos } from './registry.js';
 import { loadTemplates, newsText, objective, renderBrief } from './briefs.js';
+import { candidates, parsePriority, parseUntil, readPriority, stopReason } from './continue.js';
 import { Budget, MAX_PASSES, countInterrupted, needsPrecheck } from './cycle.js';
 import { canInstallPrePush, installPrePush, removePrePush, snapshot } from './guard.js';
 import { buildArgs, killSessions, mcpServersFor, readAgents, realClaude } from './launch.js';
@@ -19,7 +20,7 @@ import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
 import { runPool } from './pool.js';
 import { schemaFor } from './schemas.js';
 import { resolveLotRepos } from '../repos.js';
-import { excludeState, lotKey, lotRepoPaths, lotSlug, neighbourDirs, newLot, RunStore } from './state.js';
+import { excludeState, lotFinished, lotKey, lotRepoPaths, lotSlug, neighbourDirs, newLot, RunStore } from './state.js';
 import { linkNodeBin, nvmVersionsDir, resolveNode } from './node-env.js';
 import { quotaText, renderTable } from './table.js';
 import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveModulesDir, snapshotExists, withoutLaunchVars, spawnReexec, takeSnapshot, toolDirOf } from './snapshot.js';
@@ -59,7 +60,7 @@ function lotArg(text) {
     return { project: m[1], lot: m[2], model: m[3] };
 }
 export function parseOrchestrateArgs(argv) {
-    const a = { lots: [], dryRun: false, watch: false, answers: [] };
+    const a = { lots: [], dryRun: false, watch: false, continue: false, answers: [] };
     const optional = (i) => (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-') && !LOT_LIKE.test(argv[i + 1]) ? argv[i + 1] : undefined);
     for (let i = 0; i < argv.length; i++) {
         const t = argv[i];
@@ -86,6 +87,12 @@ export function parseOrchestrateArgs(argv) {
             a.maxSessions = parseMaxSessions(value(t));
         else if (t === '--wave')
             a.wave = value(t);
+        else if (t === '--continue')
+            a.continue = true;
+        else if (t === '--until')
+            a.until = value(t);
+        else if (t === '--priority')
+            a.priority = parsePriority(value(t));
         else if (t === '--answer') {
             const target = lotArg(value(t));
             a.answers.push({ project: target.project, lot: target.lot, text: value(t) });
@@ -100,9 +107,8 @@ export function parseOrchestrateArgs(argv) {
 /** Ce qu'un projet fournit à l'orchestrateur : sa configuration et la lecture de son plan (comme le CLI). */
 export function projectEnv(repo) {
     const configPath = join(repo, 'cadence.yaml');
-    const planConfig = readPlanConfig(configPath, repo);
-    const planPath = resolve(repo, planConfig?.path ?? 'docs/plan/raf.yaml');
-    return { config: readOrchestrateConfig(configPath), loadPlan: () => Plan.load(planPath, { ...planConfig?.settings, config: configPath }), configPath };
+    const loadPlan = planLoader(repo);
+    return { config: readOrchestrateConfig(configPath), loadPlan, configPath };
 }
 const isProject = (dir) => existsSync(join(dir, 'docs/plan/raf.yaml')) || (existsSync(join(dir, 'cadence.yaml')) && /^plan\s*:/m.test(readFileSync(join(dir, 'cadence.yaml'), 'utf8')));
 function resolveTargets(args, io, refusals) {
@@ -350,6 +356,12 @@ export async function orchestrate(argv, io, deps) {
     const args = parseOrchestrateArgs(argv);
     const launch = io.cwd;
     const today = io.env.RAF_TODAY && isDay(io.env.RAF_TODAY) ? io.env.RAF_TODAY : toDay(io.now());
+    if ((args.until !== undefined || args.priority !== undefined) && !args.continue)
+        throw new RafError('--until et --priority s\'utilisent avec --continue');
+    if (args.until !== undefined)
+        args.untilAt = parseUntil(args.until, io.now()); // heure invalide ou passée : refus avant d'agir
+    if (args.continue)
+        priorityOf(args, launch); // une clé priority: illisible du cadence.yaml : refus avant d'agir, lots donnés ou non
     if (args.watch && args.status === undefined)
         throw new RafError('--watch s\'utilise avec --status');
     if (args.interval !== undefined && !args.watch)
@@ -390,13 +402,21 @@ export async function orchestrate(argv, io, deps) {
     }
     if (args.resume !== undefined)
         return resume(args, argv, io, deps, launch, today);
-    if (args.lots.length === 0)
-        throw new RafError('usage : cadence orchestrate <projet>:<lot>… [--budget 2M] [--max-sessions 2] [--dry-run] | --status [vague] [--watch [--interval 10]] | --resume [vague] [--answer projet:lot "réponse"]');
+    if (args.lots.length === 0 && !args.continue)
+        throw new RafError('usage : cadence orchestrate <projet>:<lot>… [--budget 2M] [--max-sessions 2] [--dry-run] [--continue [--until 18:00] [--priority a,b]] | --status [vague] [--watch [--interval 10]] | --resume [vague] [--answer projet:lot "réponse"]');
     const refusals = [];
     const targets = resolveTargets(args, io, refusals);
     const pre = await preflight(args, targets, io, deps, launch);
     refusals.push(...pre.refusals);
     const budget = args.budget ?? DEFAULT_BUDGET;
+    const firstSkipped = [];
+    // --continue sans lot donné : le premier tour est tiré du plan ; rien de prêt, ou tout refusé, vaut un refus avant d'agir.
+    if (args.continue && args.lots.length === 0 && refusals.length === 0) {
+        const first = await draw(args, io, deps, launch, new Set(), budget, maxSessions(args, io));
+        pre.lots.push(...first.lots);
+        firstSkipped.push(...first.skipped);
+        refusals.push(...(first.lots.length ? [] : first.skipped.length ? first.skipped : ['--continue : aucun lot prêt dont l\'estimation tient dans le budget']));
+    }
     if (refusals.length) {
         for (const r of refusals)
             io.err(`orchestrate : ${r}`);
@@ -409,6 +429,8 @@ export async function orchestrate(argv, io, deps) {
         if (args.wave && existsSync(join(RunStore.runsDir(launch), id)))
             return waveExists(args.wave, io);
         dryRun(pre.lots, io, deps, budget, id);
+        if (args.continue)
+            await continueDryRun(args, io, deps, launch, pre.lots, budget, firstSkipped);
         return 0;
     }
     if (deps.snapshot) {
@@ -446,6 +468,11 @@ export async function orchestrate(argv, io, deps) {
         }
     }
     const id = store.id;
+    // Les candidats refusés au premier tirage : leur cause dit pourquoi ils ne jouent pas (même ligne que celles des tirages suivants).
+    for (const s of firstSkipped) {
+        io.err(`orchestrate : lot sauté — ${s}`);
+        store.journal(`continue : lot sauté — ${s}`);
+    }
     const wave = { id, created: io.now().toISOString(), cwd: launch, budget, consumed: 0, cacheRead: 0, status: 'running', pid: process.pid, lots: pre.lots.map((l) => lotKey(l.project, l.lot)) };
     // Une vague qui n'a pas atteint `wave.json` (refus au verrou, démarrage en échec) ne laisse pas son dossier réservé :
     // le même `--wave` se relance, et `reserve` ne le prend pas pour une vague existante.
@@ -460,7 +487,7 @@ export async function orchestrate(argv, io, deps) {
                 l.node.link = (deps.linkNode ?? linkNodeBin)(store.dir, l.node.version, l.node.bin);
             store.writeLot(l);
         }
-        const code = await execute(wave, pre.lots, store, io, deps, today, maxSessions(args, io));
+        const code = await continueRounds(await execute(wave, pre.lots, store, io, deps, today, maxSessions(args, io)), wave, pre.lots, store, io, deps, today, args, launch);
         abandon();
         return code;
     }
@@ -469,6 +496,152 @@ export async function orchestrate(argv, io, deps) {
         throw e;
     }
 }
+const priorityOf = (args, launch) => args.priority ?? readPriority(launch);
+/**
+ * Tire jusqu'à `n` lots prêts du plan (L147), dans l'ordre de priorité, et les passe au contrôle préalable comme un lot donné :
+ * un lot refusé est sauté, sa cause rendue dans `skipped`. `exclude` reçoit chaque lot tiré ou refusé pour lui-même, pas ceux d'un
+ * dépôt refusé ni un lot qui ne tient pas dans le reste du budget (il tiendra peut-être au tour suivant).
+ * Un tour tire au plus UN lot par dépôt (le pool joue à la suite les lots d'un même dépôt, `--max-sessions` ne servirait à rien) ;
+ * les lots écartés pour cela complètent le tour, dans l'ordre, quand aucun autre dépôt n'a de lot prêt.
+ */
+async function draw(args, io, deps, launch, exclude, remaining, n) {
+    const lots = [];
+    const skipped = [];
+    const badRepos = new Set();
+    const used = new Set();
+    const deferred = [];
+    /** `spread` : premier passage, un dépôt déjà pris ce tour renvoie le lot au second ; sinon (second passage) le lot complète le tour. */
+    const attempt = async (c, repo, spread, checked) => {
+        const key = lotKey(c.project, c.lot.id);
+        if (badRepos.has(repo))
+            return;
+        if (spread && used.has(repo))
+            return void deferred.push({ c, repo });
+        const pre = checked ?? (await preflight(args, [{ project: c.project, projectDir: c.dir, repo, lot: c.lot.id, model: 'sonnet' }], io, deps, launch));
+        if (pre.refusals.length) {
+            // Un refus propre au lot l'écarte pour la vague ; celui d'un dépôt (arbre sale, orchestration en cours, pre-push) est passager :
+            // le dépôt est sauté pour ce tirage seulement, une ligne, et ses lots restent tirables au suivant.
+            const own = pre.refusals.filter((r) => r.startsWith(`${key} : `));
+            if (own.length)
+                exclude.add(key);
+            if (own.length < pre.refusals.length)
+                badRepos.add(repo);
+            skipped.push(...pre.refusals.filter((r) => !skipped.includes(r)));
+            return;
+        }
+        const lot = pre.lots[0];
+        if (lot.budget > remaining)
+            return; // pas exclu : le budget du tour suivant le permettra peut-être
+        if (spread && lotRepoPaths(lot).some((r) => used.has(r)))
+            return void deferred.push({ c, repo, pre }); // un dépôt voisin déjà pris ce tour
+        exclude.add(key);
+        remaining -= lot.budget;
+        lots.push(lot);
+        for (const r of lotRepoPaths(lot))
+            used.add(r);
+    };
+    for (const c of candidates(launch, { priority: priorityOf(args, launch), exclude, remaining })) {
+        if (lots.length >= n)
+            break;
+        const repo = gitRoot(c.dir);
+        if (repo)
+            await attempt(c, repo, true);
+    }
+    for (const d of deferred) {
+        if (lots.length >= n)
+            break;
+        await attempt(d.c, d.repo, false, d.pre);
+    }
+    return { lots, skipped };
+}
+/** Nombre de tours que la simulation de `--dry-run --continue` déroule au plus. */
+const DRY_RUN_ROUNDS = 10;
+/**
+ * `--dry-run --continue` : ce que les tirages suivants joueraient, par tour, avec la même fonction `draw` que la vague (un lot par dépôt
+ * par tour, contrôle préalable, budget) ; les lots sautés disent pourquoi. Le budget est décompté sur l'estimation des lots tirés
+ * (la consommation réelle n'est pas connue). `firstSkipped` : causes écartées au premier tirage, quand il a fourni les lots donnés.
+ */
+async function continueDryRun(args, io, deps, launch, given, budget, firstSkipped) {
+    io.out(`--continue : priorité ${priorityOf(args, launch).join(' > ') || '(aucune déclarée : ordre alphabétique)'}${args.until ? ` · jusqu'à ${args.until}` : ''}`);
+    const said = new Set();
+    const skip = (causes) => {
+        for (const s of causes) {
+            if (said.has(s))
+                continue;
+            said.add(s);
+            io.out(`  lot sauté — ${s}`);
+        }
+    };
+    skip(firstSkipped);
+    const exclude = new Set(given.map((l) => lotKey(l.project, l.lot)));
+    let remaining = budget - given.reduce((sum, l) => sum + (l.budget ?? 0), 0);
+    const cap = maxSessions(args, io);
+    const rounds = [];
+    for (let round = 1; round <= DRY_RUN_ROUNDS && remaining > 0; round++) {
+        const drawn = await draw(args, io, deps, launch, exclude, remaining, cap);
+        skip(drawn.skipped);
+        if (drawn.lots.length === 0)
+            break;
+        rounds.push(`tour ${round} : ${drawn.lots.map((l) => lotKey(l.project, l.lot)).join(', ')}`);
+        remaining -= drawn.lots.reduce((sum, l) => sum + (l.budget ?? 0), 0);
+    }
+    io.out(rounds.length ? `  tirés ensuite, par tour (budget décompté sur les estimations) : ${rounds.join(' · ')}${rounds.length === DRY_RUN_ROUNDS ? ' · …' : ''}` : '  aucun autre lot prêt à tirer');
+}
+/** Lots rendus ou en échec de suite, en comptant depuis le dernier lot de la vague. */
+function handedBackStreak(all) {
+    let n = 0;
+    for (const l of [...all].reverse()) {
+        if (l.status === 'handed-back' || l.status === 'failed')
+            n++;
+        else
+            break;
+    }
+    return n;
+}
+/**
+ * `--continue` (L147) : tant qu'aucune borne ne joue, tire jusqu'à `cap` lots prêts du plan et les joue dans la même vague
+ * (même budget, même dossier d'état). Sans `--continue`, rend le code tel quel. Bornes : budget, `--until`, limite d'usage,
+ * question posée, deux lots rendus de suite, vague interrompue, plus de lot prêt dont l'estimation tient dans le budget restant.
+ */
+async function continueRounds(first, wave, all, store, io, deps, today, args, launch) {
+    if (!args.continue || first === 2)
+        return first; // 2 : refus au verrou, rien n'a tourné
+    const say = (line) => {
+        io.out(line);
+        store.journal(line);
+    };
+    const exclude = new Set(all.map((l) => lotKey(l.project, l.lot)));
+    const cap = maxSessions(args, io);
+    let code = first;
+    for (;;) {
+        const questions = all.filter((l) => l.status === 'question').length;
+        const remaining = wave.status === 'suspended-budget' ? 0 : wave.budget - wave.consumed;
+        const why = stopReason({ now: io.now(), until: args.untilAt, quotaHit: wave.status === 'suspended-quota', questions, streak: handedBackStreak(all), interrupted: wave.status === 'interrupted' && questions === 0, remaining });
+        if (why) {
+            say(`continue : arrêt — ${why}`);
+            return code;
+        }
+        const drawn = await draw(args, io, deps, launch, exclude, remaining, cap);
+        for (const s of drawn.skipped)
+            say(`continue : lot sauté — ${s}`);
+        if (drawn.lots.length === 0) {
+            say("continue : arrêt — plus aucun lot prêt dont l'estimation tient dans le budget restant");
+            return code;
+        }
+        for (const l of drawn.lots) {
+            if (l.node)
+                l.node.link = (deps.linkNode ?? linkNodeBin)(store.dir, l.node.version, l.node.bin);
+            store.writeLot(l);
+            wave.lots.push(lotKey(l.project, l.lot));
+        }
+        store.writeWave(wave);
+        all.push(...drawn.lots);
+        say(`continue : tire ${drawn.lots.map((l) => lotKey(l.project, l.lot)).join(', ')}`);
+        code = await execute(wave, drawn.lots, store, io, deps, today, cap, all);
+        if (code === 2)
+            return code;
+    }
+}
 function contexts(lots, envs, wctx) {
     return lots.map((lot, i) => ({ wave: wctx, lot, config: envs[i].config, loadPlan: envs[i].loadPlan }));
 }
@@ -603,7 +776,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         saveWave();
         release();
     });
-    const finished = (l) => l.status === 'ready' || l.status === 'handed-back' || l.status === 'failed';
+    const finished = lotFinished;
     try {
         await runPool(ctxs, cap, all, (c) => {
             // Un dépôt dont tous les lots de la vague (reprise comprise) sont prêts ou rendus peut être livré pendant que la vague continue ailleurs.
@@ -742,7 +915,7 @@ async function resume(args, argv, io, deps, launch, today) {
             io.out(line);
         return 0;
     }
-    return execute(wave, live, store, io, deps, today, maxSessions(args, io), lots);
+    return continueRounds(await execute(wave, live, store, io, deps, today, maxSessions(args, io), lots), wave, lots, store, io, deps, today, args, launch);
 }
 /** Dépendances réelles : `claude` (ou CADENCE_CLAUDE_BIN), agents et gabarits du paquet, journaux de ~/.claude. */
 export function realOrchestrateDeps(env) {

package/dist/orchestrate/continue.js

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { parse } from 'yaml';
+import { nextUp } from '../audit.js';
+import { planLoader } from '../config.js';
+import { gitRoot } from '../git.js';
+import { findProjects, isProject } from '../lead.js';
+import { RafError } from '../plan.js';
+import { lotBudget } from './command.js';
+/** `--until 18:00` : l'heure d'aujourd'hui (date de `now`) à partir de laquelle la vague ne tire plus de lot. */
+export function parseUntil(text, now) {
+    const m = /^(\d{1,2}):(\d{2})$/.exec(text.trim());
+    if (!m || Number(m[1]) > 23 || Number(m[2]) > 59)
+        throw new RafError(`--until invalide : ${text} (HH:MM, ex. 18:00)`);
+    const at = new Date(now);
+    at.setHours(Number(m[1]), Number(m[2]), 0, 0);
+    if (at.getTime() <= now.getTime())
+        throw new RafError(`--until ${text} : heure déjà passée aujourd'hui`);
+    return at;
+}
+/** `--priority cadence,maritime` : noms de projets, du plus prioritaire au moins prioritaire. */
+export function parsePriority(text) {
+    const names = text.split(',').map((n) => n.trim()).filter(Boolean);
+    if (names.length === 0)
+        throw new RafError(`--priority invalide : ${text} (noms de projets séparés par des virgules)`);
+    return names;
+}
+/** Clé `priority:` du cadence.yaml du dossier de lancement (le dossier parent des projets) ; absente : aucune priorité déclarée. */
+export function readPriority(launchDir) {
+    const file = join(launchDir, 'cadence.yaml');
+    if (!existsSync(file))
+        return [];
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const p = raw?.priority;
+    if (p == null)
+        return [];
+    if (!Array.isArray(p) || p.length === 0 || p.some((n) => typeof n !== 'string' || !n.trim()))
+        throw new RafError(`${file} : priority doit être une liste de noms de projets`);
+    return p.map((n) => n.trim());
+}
+/** Rang d'un projet dans la priorité : son nom, ou un nom suivi de « - » (`maritime` couvre `maritime-atlas`) ; les autres passent après tous les déclarés. */
+export function priorityRank(project, priority) {
+    const i = priority.findIndex((n) => project === n || project.startsWith(`${n}-`));
+    return i < 0 ? priority.length : i;
+}
+/** Un lot « à décider » (« à décider avec Sylvain », « (à décider) » ; titre ou note) attend une décision humaine : jamais tiré. */
+export function decisionPending(lot) {
+    return /à décider/i.test([lot.title, ...lot.notes.map((n) => n.text)].join('\n'));
+}
+/**
+ * Les lots tirables sous `launch` : prêts (à faire, `after` levé, ni récurrents ni en cours), ni « à décider avec Sylvain » ni déjà
+ * dans la vague, dont le budget tient dans `remaining` ; projets dans l'ordre de priorité (puis alphabétique), lots dans l'ordre du plan
+ * (gains rapides d'abord). `launch` est un projet : lui seul ; sinon ses sous-dossiers qui en sont. Un plan illisible est sauté.
+ */
+export function candidates(launch, o) {
+    const dirs = isProject(launch) ? [launch] : findProjects(launch);
+    const out = [];
+    const ranked = dirs.map((dir) => ({ dir, project: basename(dir) })).sort((a, b) => priorityRank(a.project, o.priority) - priorityRank(b.project, o.priority) || a.project.localeCompare(b.project));
+    for (const { dir, project } of ranked) {
+        let ready;
+        try {
+            ready = nextUp(planLoader(gitRoot(dir) ?? dir)().lots()).ready;
+        }
+        catch {
+            continue;
+        }
+        for (const lot of ready) {
+            if (o.exclude.has(`${project}:${lot.id}`) || decisionPending(lot) || lotBudget(lot.estimate) > o.remaining)
+                continue;
+            out.push({ project, dir, lot });
+        }
+    }
+    return out;
+}
+/** Pourquoi la vague ne tire plus de lot, ou null quand elle peut continuer. */
+export function stopReason(f) {
+    if (f.interrupted)
+        return 'vague interrompue (incident ou signal)';
+    if (f.quotaHit)
+        return "limite d'usage atteinte";
+    if (f.questions > 0)
+        return `${f.questions} question(s) posée(s) à la vague`;
+    if (f.streak >= 2)
+        return 'deux lots rendus de suite';
+    if (f.until && f.now.getTime() >= f.until.getTime())
+        return 'fenêtre horaire close (--until)';
+    if (f.remaining <= 0)
+        return 'budget épuisé';
+    return null;
+}

package/dist/orchestrate/cycle.js

@@ -249,6 +249,20 @@ function briefFor(c, kind) {
 export const lotSpent = (l) => l.steps.reduce((n, s) => n + (s.tokens?.counted ?? 0), 0);
 /** Le lot a dépensé son propre budget (L78) : il ne compte plus que sur le lead, la vague garde le sien pour les autres. */
 const lotOver = (l) => l.budget !== undefined && lotSpent(l) >= l.budget;
+/**
+ * Coût réservé à la revue qui suit une passe de correction (L145). Réserve fixe de 65 k tokens comptés, proche du p90 des
+ * revues complètes. Mesure faite le 2026-10-09 sur les journaux `.cadence/runs/*` (67 dossiers de vague du 04 au 09-10,
+ * `tokens.counted` des `N-review.json`, `N-review-small.json`, `N-ux.json` ; aucun journal `ux` conservé, 2 `review-small`
+ * sans `tokens.counted` écartés ; p90 par interpolation linéaire) : 187 revues, médiane 43,4 k, p90 62,7 k, max 105,9 k ;
+ * 114 revues courtes (review-small, après la passe des mineurs), médiane 37,4 k, p90 67,6 k, max 82,7 k ; ensemble des
+ * 301 revues, médiane 42,3 k, p90 67,0 k, max 105,9 k. La revue courte a donc un p90 plus haut que la revue complète : 65 k
+ * couvre 170 revues sur 187 (90,9 %) mais 99 revues courtes sur 114 (86,8 %). Une passe fix ne part que s'il reste de quoi payer cette revue.
+ * Seule exception : des tests rouges après une écriture (work() appelle toFix() sans revue) — la passe fix suivante peut
+ * alors être refusée et le lot revient au lead sans revue, avec ses constats.
+ */
+export const REVIEW_RESERVE = 65_000;
+/** Une passe de correction laisse-t-elle de quoi rejouer la revue dans le budget du lot ? Sans budget de lot : toujours. */
+const fixAffordable = (l) => l.budget === undefined || lotSpent(l) + REVIEW_RESERVE < l.budget;
 /** Pourquoi plus aucune session ne doit partir (incident, quota, budget), sinon null. */
 function halted(w, lot) {
     if (w.incident)
@@ -278,9 +292,10 @@ async function session(c, kind) {
     const halt = halted(w, l);
     if (halt)
         return suspend(c, halt);
-    if (lotOver(l))
-        return overBudget(c);
     const write = kind === 'implement' || kind === 'fix';
+    // Le budget du lot borne l'écriture, jamais la revue (L145) : une revue est jouée dès que le code est à relire (sauf tests rouges après une écriture, cf. REVIEW_RESERVE), la passe fix réserve son coût.
+    if (write && (lotOver(l) || (kind === 'fix' && !fixAffordable(l))))
+        return overBudget(c, kind === 'fix' && !lotOver(l));
     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);
@@ -435,12 +450,23 @@ function lostVerdict(c, kind, report) {
     c.lot.warnings.push(text);
     return ` ; ${text}`;
 }
-/** Budget du lot atteint avant une session : le lot est rendu au lead (reprendre ne lui rendrait pas de budget), les autres continuent. */
-function overBudget(c) {
+/**
+ * Budget du lot atteint avant une session d'écriture : le lot est rendu au lead (reprendre ne lui rendrait pas de budget), les autres continuent.
+ * `reserve` : le budget n'est pas dépensé, mais la passe fix ne laisserait pas de quoi rejouer la revue (L145).
+ */
+function overBudget(c, reserve = false) {
     const l = c.lot;
     // Une réponse du lead encore en attente n'a pas été consommée : elle ne doit pas se perdre sans qu'on le dise.
     const answer = l.pendingAnswer ? ` ; la réponse du lead (« ${l.pendingAnswer} ») n'a pas été jouée` : '';
-    return stop(c, 'handed-back', `budget du lot atteint (${lotSpent(l)} / ${l.budget} tokens comptés, dérivé de l'estimate) : étape « ${l.next ?? '?'} » non jouée${answer}, à décider par le lead`);
+    const why = reserve ? `budget du lot : ${lotSpent(l)} / ${l.budget} tokens comptés (dérivé de l'estimate), il ne reste pas de quoi payer la revue qui suivrait la correction (${REVIEW_RESERVE} réservés)` : `budget du lot atteint (${lotSpent(l)} / ${l.budget} tokens comptés, dérivé de l'estimate)`;
+    // Tests rouges après une écriture : la passe fix refusée aurait suivi, le lot revient sans revue (L145) — la cause le dit.
+    const red = l.next === 'fix' && l.constats.some((k) => k.source === 'tests');
+    // Passe d'écriture qui vient d'être jouée, nommée d'après le compteur : l.pass - 1 passes de correction l'ont précédée (minorPass reste vrai après la passe des mineurs).
+    const played = l.pass - 1;
+    const after = l.minorPass && played === (l.minorPassAt ?? 0) ? 'la passe des mineurs' : played > 0 ? `la passe fix ${played}` : "l'implémentation";
+    const prefix = red ? `tests rouges après ${after}, correction suivante non abordable : ` : '';
+    const unreviewed = red ? ' ; le lot revient sans revue, avec ses constats' : '';
+    return stop(c, 'handed-back', `${prefix}${why} : étape « ${l.next ?? '?'} » non jouée${answer}${unreviewed}, à décider par le lead`);
 }
 function suspend(c, why) {
     transition(c, 'suspended', why);
@@ -699,10 +725,6 @@ async function review(c, kind) {
         suspend(c, halt); // la session n'aurait pas lieu : l'application ne se lance pas pour rien
         return;
     }
-    if (lotOver(l)) {
-        overBudget(c);
-        return;
-    }
     c.wave.log(`${lotKey(l.project, l.lot)} · lancement de l'application (${ux.url})`);
     const app = await startApp({ command: ux.command, url: ux.url, cwd: l.repo, nodeBin: l.node?.link, log: join(c.wave.store.lotDir(l.project, l.lot), 'ux-app.log'), timeoutMs: (ux.timeout ?? APP_TIMEOUT_S) * 1000 });
     try {
@@ -764,10 +786,10 @@ async function reviewStep(c, kind) {
     // Revue conforme avec mineurs : une seule passe de correction des mineurs, avant de conclure (rien sous le tapis).
     // Budget épuisé : la passe n'aurait aucune session pour la jouer, le lot conclut sur la revue conforme et rend les mineurs.
     const wanted = summary.conforme && uxOk && !l.minorPass && !l.light && minors.length > 0; // lot léger : les mineurs restent des notes (L108)
-    const noBudget = wanted && (w.budget.exhausted || lotOver(l)) && !w.incident && !w.quota.hit;
+    const noBudget = wanted && (w.budget.exhausted || !fixAffordable(l)) && !w.incident && !w.quota.hit;
     const minorPass = wanted && !noBudget;
     if (noBudget)
-        l.warnings.push(`${w.budget.exhausted ? 'budget' : 'budget du lot'} atteint : la passe des mineurs n'a pas eu lieu, mineurs rendus en propositions`);
+        l.warnings.push(`${w.budget.exhausted ? 'budget atteint' : 'budget du lot trop juste pour payer la revue qui suivrait'} : la passe des mineurs n'a pas eu lieu, mineurs rendus en propositions`);
     // Les mineurs confiés à la passe ont pu être proposés par une revue non conforme antérieure : si la revue qui la suit est
     // conforme, ils sont traités et ne restent pas en propositions (ceux que cette revue signale encore sont ajoutés juste après).
     if (l.minorPass && !minorPass && summary.conforme && uxOk && l.minorLines?.length) {
@@ -789,6 +811,7 @@ async function reviewStep(c, kind) {
     addProposals(c, rep, 'code', !minorPass);
     if (minorPass) {
         l.minorPass = true;
+        l.minorPassAt = l.pass;
         l.minorLines = rep.constats.filter((k) => k.gravite === 'mineur').map((k) => minorLine('code', k));
         l.minorFix = true;
         l.constats = minors;

package/dist/orchestrate/registry.js

@@ -2,6 +2,8 @@ import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { processStart } from '../proc.js';
+import { gitCommonDir } from '../git.js';
+import { lotFinished, lotKey, lotRepoPaths, RunStore } from './state.js';
 import { activeLock, holderAlive, releaseLock, takeLock } from './lock.js';
 /**
  * État commun à toutes les vagues de l'utilisateur, quel que soit le dossier d'où elles partent : le registre
@@ -137,3 +139,26 @@ export async function acquireSlot(home, cap, opts) {
         await new Promise((r) => setTimeout(r, pollMs + Math.random() * pollMs * 0.25));
     }
 }
+/** .git commun du dépôt `dir` (partagé par ses worktrees) ; null si `dir` n'est pas un dépôt. */
+const commonDir = (dir) => {
+    try {
+        return gitCommonDir(dir);
+    }
+    catch {
+        return null;
+    }
+};
+/** Lots de la vague `pid` qui travaillent encore dans `repo` (en cours, en file ou suspendus) ; null si l'état de la vague est illisible. */
+export function openLotsIn(home, pid, repo) {
+    try {
+        const w = liveWaves(home).find((x) => x.pid === pid);
+        const store = w && RunStore.find(w.cwd, w.wave);
+        if (!store)
+            return null;
+        const mine = commonDir(repo);
+        return store.lots().filter((l) => !lotFinished(l) && lotRepoPaths(l).some((r) => r === repo || (mine !== null && commonDir(r) === mine))).map((l) => lotKey(l.project, l.lot));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/orchestrate/state.js

@@ -4,6 +4,8 @@ import { gitCommonDir, gitRoot } from '../git.js';
 export function newLot(o) {
     return { ...o, status: 'queued', pass: 0, next: null, steps: [], constats: [], verdict: null, uxVerdict: null, questions: [], choix: [], answers: [], proposals: [], warnings: [], outcome: null };
 }
+/** Un lot fini ne travaille plus dans son dépôt : prêt, rendu ou échoué. */
+export const lotFinished = (l) => l.status === 'ready' || l.status === 'handed-back' || l.status === 'failed';
 /** Tous les dépôts où les sessions du lot travaillent : celui du projet, puis ses voisins. */
 export const lotRepoPaths = (l) => [l.repo, ...(l.repos ?? []).map((r) => r.path)];
 /** Les dépôts voisins du lot, donnés en `--add-dir` à ses sessions. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylad/cadence",
-  "version": "0.21.0",
+  "version": "0.23.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

@@ -97,6 +97,37 @@ questions back (`--resume --answer <project>:<lot> "…"`), look at the UX revie
 the plan is the lead's decision. A minor finding becomes a lot of its own only if it describes an observable bug (a wrong output, a crash, a measured regression); otherwise it stays a note of the originating lot, so that a review never feeds the next one. If an orchestrated wave is running in a repository, do not commit there
 and do not deliver it (`cadence deliver` refuses).
 
+### 2c. Chaining without the human
+
+Once the human has given the **first choice and the order** (the lots, and the priority: `--priority` or the
+`priority:` list of the parent folder's `cadence.yaml`), the lead does not come back to ask « next? ». For each lot a
+wave hands back **ready**, it chains, in this order, one project at a time: re-verify it yourself (section 3, point 2),
+`raf done` (a read-only plan: the project's own command; a `visible` lot first waits for the human's UX verdict, `raf ux`, and is neither closed nor delivered without it — the chain goes on with the other lots), push, deliver (section 4), the `qa-reviewer` check that
+section asks for; then it starts the next wave, in the declared priority — `cadence orchestrate --continue --priority …` draws the next ready lot
+of the plan itself (section 2b), and the limits of section « Limits that always apply » still hold. A lot that was not
+handed back ready (refused, review not compliant after the correction passes, red delivery, blocking QA finding) is
+not chained over: it is reported, and the chain goes on with the lots that do not depend on it.
+
+**The threshold.** Before every new wave, read the context of the lead session with `cadence session context`: the
+`cadence-hud` mod publishes the context of each session, one file per session named after its id, and the command reads the
+one named by `$CLAUDE_CODE_SESSION_ID` (Claude Code sets it in the environment of your Bash, so it is your own session,
+whatever the folder; `--session <id>` overrides it). Without the variable it falls back to the folder only if a single
+session publishes for it; two sessions in one folder make it exit 2 ("pass --session"), never guess the latest. It prints
+`ctx 42 % (84000/200000)`, the figure the `ctx` segment of the band shows, which the band publishes to
+a file because it is only a rendering the model cannot see. If the command fails (exit code 2: the band is not loaded in
+this session, several sessions share the folder without the variable, or the figure is older than two minutes), treat it as
+**at the threshold**: you cannot prove you are under it, and without the band loaded the lead does not chain.
+From **60 %** upward, start nothing: at the threshold the lead runs `session-close` in each project touched, writes its
+memory (filtered, as `session-close` says), and records three lines for next time with `cadence session next` — the wave
+that was about to start comes first among them. Under it, chain. The lead says in one sentence which side of the threshold
+it is on each time it chains or stops; it never waits for the figure to move (never a polling loop).
+
+**What stays with the human**: the first choice and the order; the questions a session raised (the lead brings them
+back at once and does not answer in the human's place); the UX reservations (`raf ux` is recorded on the human's
+verdict, a UX reviewer's captures are looked at by the human). While a question or a UX reservation is pending on a
+lot, the chain goes on with the other lots and does not wait for it. A delivery that needs the human's confirmation
+(their standing instructions, section 4) is a stop of the chain, not a bypass.
+
 ## 3. Check
 
 0. After an orchestrated wave the review is already done, by a fresh session: read the table, then go to