@sylad/cadence 0.22.0 → 0.24.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.22.0",
+      "version": "0.24.0",
       "source": "./",
       "author": {
         "name": "Sylvain Ladoire"
@@ -17,7 +17,7 @@
     {
       "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. Works without the cadence CLI, except the per-project plan progress, which needs `cadence` on the PATH.",
-      "version": "0.4.0",
+      "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.22.0",
+  "version": "0.24.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.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
+**0.24.0**: `cadence orchestrate --drop <project:lot>` and `--stop-after-current` steer a live wave from another terminal, `--resume --drop` removes a lot before replaying a stopped wave (L79); the final table of a wave says « livrable jusqu'à <sha> » for a ready lot stacked under a lot handed back, with `git push origin <sha>:main && cadence deliver --sha <sha>` (L76); a version commit (version fields, `CHANGELOG.md`, the README's « What's new ») no longer asks for a new code review (L72). **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),
@@ -97,7 +97,7 @@ raf gantt                         # docs/plan/gantt.html
 | `raf list [--status s]` | flat list |
 | `raf ignore <sha> \| "exact subject" [--reason text]` | acknowledge a commit without a lot (tooling chore, a plan commit citing an unknown id) without rewriting history: a dated, reasoned line in the plan's `acknowledged:` section; a sha is exact, a subject covers every commit carrying it |
 | `raf check --ignored` | list the acknowledged commits with their date and reason |
-| `raf check [--since date] [--idle 7]` | since the plan's adoption date by default (a visible lot without a public title is only a `⚠` warning: it never changes the exit code): commits without a lot (commits touching only plan files are exempt), unknown ids, `todo` lots that already have commits, idle lots, `done` lots with open sub-tasks, bad or circular dependencies |
+| `raf check [--since date] [--idle 7]` | since the plan's adoption date by default (a visible lot without a public title is only a `⚠` warning: it never changes the exit code): commits without a lot (commits touching only plan files, or only version fields, `CHANGELOG.md` and the README's « What's new » section, are exempt), unknown ids, `todo` lots that already have commits, idle lots, `done` lots with open sub-tasks, bad or circular dependencies |
 | `raf gantt [-o file]` | standalone Gantt page |
 | `raf hook install` | add the post-commit hook (read-only, never blocks) and the pre-commit hook (does nothing unless `hook.autostart` says so, see below) |
 
@@ -323,7 +323,7 @@ refuses a lot that has at least one commit citing it and no recorded verdict
 (`--force` to override), and `raf check` reports such lots finished after the
 `reviewSince` day. A lot with no commit has nothing to review; neither does a
 lot whose only commits touch plan files alone (the plan, a file listed under
-`plan.files`, or the QA expectations file), predate the plan's `since` or match an `ignore:` pattern — `raf commits <id>` prints exactly the counted set.
+`plan.files`, or the QA expectations file), are version commits (see [Releasing](#releasing)), predate the plan's `since` or match an `ignore:` pattern — `raf commits <id>` prints exactly the counted set.
 
 The verdict is tied to what was reviewed: `raf review` stores it on the lot with
 the sha of the lot's latest counted commit (`review: { date, verdict, commit }`,
@@ -358,8 +358,8 @@ docs:
 ```
 
 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
+a whole folder. `raf check` takes the **work commits** of every lot in progress (plan-only commits and
+version commits do not count — so a "What's new" line written in the version commit is not documentation; 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`:
 
 ```
@@ -827,9 +827,30 @@ cadence orchestrate … --dry-run              # preconditions + the plan of the
 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"]
+cadence orchestrate --resume [<wave>] [--budget 1M] [--answer ol-companion:L22 "reply"] [--drop ccc:L29]
+cadence orchestrate --drop ccc:L29 [--wave <wave>]   # from another terminal: take a lot out of the running wave
+cadence orchestrate --stop-after-current [--wave <wave>]   # from another terminal: let the running sessions finish, start nothing else
 ```
 
+**`--drop` and `--stop-after-current` — steering a running wave (L79)**: both are run from the folder the wave was launched
+from (`--wave <id>` when several waves run from it), and write a request in the wave's state folder
+(`.cadence/runs/<wave>/control.log`, append-only), which the wave reads before each session — no signal, no edit of
+`journal.log`. `--drop <project:lot>` (repeatable) takes a lot out of the wave: a lot not started yet never starts (no
+`raf start`); a lot with a session running **lets that session finish** (it is not killed), then plays no other: it is
+*handed back* (`retiré de la vague (--drop)`), its commits stay, and a lot that depended on it is handed back too. A lot
+waiting for an answer (`question`) is handed back as well, at the end of the wave or on `--resume --drop`, instead of staying in
+question forever. A lot that is unknown or already finished is refused (exit 2). `--stop-after-current` lets the sessions running finish, starts no
+other session nor lot (`arrêt demandé (--stop-after-current)`), and leaves the wave **interrupted** and resumable
+(`--resume`, which forgets the stop; `--continue` draws nothing more). Neither combines with lots to launch,
+`--continue`, `--dry-run`, `--budget` or `--answer`, nor `--status`; without a live wave from that folder they are refused
+(exit 2). A stopped wave is no longer live, so to take a lot out of it use **`--resume --drop <project:lot>`**: the lot is
+handed back instead of being replayed (an unknown or finished lot is refused, exit 2, before anything runs). A lot taken out
+this way is left out of the resume checks (repository lock, `.nvmrc` Node, dirty tree): only the lots that will be replayed can
+refuse the resume, and a refusal writes nothing to `control.log`.
+`--resume --stop-after-current` is refused (exit 2): resuming contradicts stopping.
+A wave runs on its own snapshot of the tool: one launched before L79 never reads `control.log`, so the request is written but the
+command warns `ne lit pas les demandes de contrôle` on the error output.
+
 **`--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
@@ -845,7 +866,8 @@ alphabetical order. Launched from inside a project, only that project is drawn.
 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
+a question asked (the wave stays resumable with `--answer`), two lots handed back in a row, an interrupted wave, a `--stop-after-current` request (`arrêt demandé`, even when the last running
+lots finished cleanly), 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.
@@ -1027,7 +1049,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
@@ -1063,6 +1085,15 @@ nothing readable, times out (45 min for work, 25 for a review) or fails is not r
 back with the cause. Exit codes: 0 every lot ready · 1 at least one lot handed back (question, failure,
 review still not compliant after two passes) · 2 refused before acting · 3 wave suspended.
 
+**Stacked lots** (L76): lots of one repository commit on top of each other on `main`. When a ready lot sits under a lot that
+is not ready (handed back, failed…), the final table adds a line `<project>:<lot> — livrable jusqu'à <sha> … : git push origin <sha>:main && cadence deliver --sha <sha>`:
+the last commit of the highest ready lot with no unfinished lot's commit beneath it. Ship it without the lot above by pushing
+that sha alone, then delivering it: `git push origin <sha>:main && cadence deliver --sha <sha>` (with `ci: github` the CI wait
+looks for the run of that exact sha, and GitHub only builds the tip of a push; pushing HEAD would also put the unreviewed lot
+on `main`). A lot's commits are read from git (the commits that cite it, whatever session or wave made them; plan-only and
+version commits do not count), not only from the sessions' reports, so a failed or timed-out session that committed still
+bounds the line. Nothing is printed when every lot is ready or when the ready lots sit above the unfinished one.
+
 **Formatting retry** (the only `--resume` of a session): when a session ends successfully but in plain text,
 without the `structured_output` the schema asks for (the verdict is there, not in the required shape), the
 orchestrator resumes **that same session once** (`claude -p --resume <session-id> --json-schema <same schema>`,
@@ -1298,9 +1329,16 @@ the `.claude-plugin/types` the tsconfig extends).
 A version exists in three places and is published in two; a release does all of it, in this order:
 
 1. Bump `version` in `package.json` (then `npm install` to refresh `package-lock.json`),
-   `.claude-plugin/plugin.json` and `.claude-plugin/marketplace.json`, in the commit that closes the lot.
-   Write the version's section of `CHANGELOG.md` (`## [x.y.z] - date`, what changes for the user, lots cited)
-   and refresh the « What's new » summary of this README in that same commit.
+   `.claude-plugin/plugin.json` and `.claude-plugin/marketplace.json`, and write the version's section of
+   `CHANGELOG.md` (`## [x.y.z] - date`, what changes for the user, lots cited), in **one commit that holds
+   only those files** (the version fields and the CHANGELOG, nothing else in the manifests, and the « What's new »
+   section of this README, the one place of it a release rewrites). Such a commit is
+   exempt from the code-review gate like a plan commit: it closes the lot after its review, and `raf check`
+   does not ask for a new one (nor does it count it as a commit without a lot). The « What's new »
+   summary is ordered by version, a number known only at the release and shared by several lots: write it
+   in that commit, not before the review. A commit that touches any other file
+   — or another field of a manifest, or a dependency in `package-lock.json` — is work like any other and has
+   to be reviewed.
 2. `git tag v<version> && git push origin main v<version>` — the tag starts `.github/workflows/publish.yml`,
    which publishes to npm through Trusted Publishing (OIDC, no token stored anywhere): it checks the tag
    matches `package.json`, `.claude-plugin/plugin.json` and `.claude-plugin/marketplace.json` and that `CHANGELOG.md` has a `## [x.y.z]` section for it (no section, no publication), then `npm publish --provenance`, where `prepublishOnly` runs the type-check and the

package/dist/audit.js

@@ -52,19 +52,67 @@ export function isPlanOnly(sha, plan, root) {
     const files = changedFiles(root, sha);
     return files.length > 0 && files.every((f) => own.has(f) && (f !== config || onlyPlanKeyChanged(root, sha, f)));
 }
+/** Fichiers d'une version : manifestes JSON (dont seul le champ `version` bouge) et CHANGELOG. */
+const VERSION_JSON = /(^|\/)(package\.json|package-lock\.json|\.claude-plugin\/(plugin|marketplace)\.json)$/;
+const CHANGELOG = /(^|\/)CHANGELOG\.md$/;
+const README = /^README\.md$/;
+/** Le README sans sa section « What's new », rangée par version et donc réécrite à la release. */
+function withoutWhatsNew(text) {
+    return (text ?? '').replace(/^## What's new\s*$[\s\S]*?(?=^## |(?![\s\S]))/m, '');
+}
+/** Le JSON sans les champs `version` qu'une release réécrit : la racine, `packages[""]` du lock et `plugins[]` du marketplace. */
+function withoutVersion(text) {
+    if (text === null)
+        return '{}';
+    try {
+        const json = JSON.parse(text);
+        delete json.version;
+        if (json.packages?.[''])
+            delete json.packages[''].version;
+        for (const p of Array.isArray(json.plugins) ? json.plugins : [])
+            if (p && typeof p === 'object')
+                delete p.version;
+        return JSON.stringify(json);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Commit de version (L72) : TOUS ses fichiers sont des fichiers de version — package.json, package-lock.json,
+ * .claude-plugin/plugin.json et marketplace.json, où seule la `version` change, et CHANGELOG.md, plus la section « What's new » du README (seule). Il clôt le lot
+ * après sa revue : l'exiger relu rouvrirait la porte à chaque release. Les fichiers décident, jamais le sujet.
+ */
+export function isReleaseOnly(sha, root) {
+    const files = changedFiles(root, sha);
+    // Les noms d'abord : un fichier hors version refuse le commit sans qu'aucun contenu ne soit lu.
+    if (!files.length || !files.every((f) => CHANGELOG.test(f) || README.test(f) || VERSION_JSON.test(f)))
+        return false;
+    return (files.length > 0 &&
+        files.every((f) => {
+            if (CHANGELOG.test(f))
+                return true;
+            if (README.test(f))
+                return withoutWhatsNew(fileAt(root, `${sha}^`, f)) === withoutWhatsNew(fileAt(root, sha, f));
+            if (!VERSION_JSON.test(f))
+                return false;
+            const before = withoutVersion(fileAt(root, `${sha}^`, f));
+            return before !== null && before === withoutVersion(fileAt(root, sha, f));
+        }));
+}
 /** Le commit a été acquitté par « raf ignore » : par son sha, ou par son sujet exact. */
 export function isAcknowledged(plan, c) {
     return plan.acknowledged.some((a) => (a.sha !== undefined && a.sha === c.sha) || (a.sha === undefined && a.subject === c.subject));
 }
 /**
- * N'ont pas besoin de citer un lot : un commit d'entretien du plan (cf. isPlanOnly), un commit
+ * N'ont pas besoin de citer un lot : un commit d'entretien du plan (cf. isPlanOnly), un commit de version (cf. isReleaseOnly), un commit
  * automatique dont le sujet correspond à un motif `ignore:` du plan et un commit acquitté (`raf ignore`) ;
  * un commit acquitté n'est pas non plus signalé pour un identifiant cité inconnu.
  */
 export function exemptPlanOnly(linked, plan, root) {
     const { patterns } = plan.ignore;
     const acked = (c) => isAcknowledged(plan, c);
-    const orphans = linked.orphans.filter((c) => !patterns.some((re) => re.test(c.subject)) && !acked(c) && !isPlanOnly(c.sha, plan, root));
+    const orphans = linked.orphans.filter((c) => !patterns.some((re) => re.test(c.subject)) && !acked(c) && !isPlanOnly(c.sha, plan, root) && !isReleaseOnly(c.sha, root));
     return { ...linked, orphans, unknown: linked.unknown.filter((u) => !acked(u.commit)) };
 }
 /** Fenêtre de l'audit : --since, sinon la date d'adoption du plan, sinon 30 jours. */
@@ -128,10 +176,10 @@ export function docSyncIssues(plan, root, byLot) {
         .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. */
+/** Commits qui portent du travail sur un lot : ni antérieurs à l'adoption du plan, ni réduits au plan, ni une simple version. */
 function workCommits(plan, root, commits) {
     const adopted = plan.since;
-    return commits.filter((c) => (!adopted || c.day >= adopted) && !isPlanOnly(c.sha, plan, root));
+    return commits.filter((c) => (!adopted || c.day >= adopted) && !isPlanOnly(c.sha, plan, root) && !isReleaseOnly(c.sha, root));
 }
 /** Commits liés à un lot, du plus récent au plus ancien, avant tout tri : commits de plan et d'avant l'adoption compris. */
 export function lotCommits(plan, root, lotId) {

package/dist/cli.js

@@ -20,6 +20,7 @@ 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';
@@ -43,7 +44,7 @@ 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] [--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 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"] [--drop projet:lot] ; --drop projet:lot [--wave vague] ; --stop-after-current [--wave vague]
   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 … »)
@@ -430,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)`);

package/dist/orchestrate/command.js

@@ -13,17 +13,17 @@ 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 { Budget, DROPPED, MAX_PASSES, countInterrupted, handBackDroppedQuestions, needsPrecheck } from './cycle.js';
 import { canInstallPrePush, installPrePush, removePrePush, snapshot } from './guard.js';
 import { buildArgs, killSessions, mcpServersFor, readAgents, realClaude } from './launch.js';
 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';
+import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveModulesDir, snapshotExists, waveReadsControl, withoutLaunchVars, spawnReexec, takeSnapshot, toolDirOf } from './snapshot.js';
 export const DEFAULT_BUDGET = 2_000_000;
 /** Tokens comptés par jour d'estimate (L78) ; mesuré le 06-10 : des lots de 0,5 j ont mangé 192 à 531 k, des lots de 1 j 455 à 468 k (2 M pour 6 lots) ; le plafond est posé sous ces mesures pour arrêter vraiment. */
 const LOT_BUDGET_PER_DAY = 400_000;
@@ -60,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, continue: false, answers: [] };
+    const a = { lots: [], dryRun: false, watch: false, continue: false, answers: [], drop: [], stopAfterCurrent: false };
     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];
@@ -87,6 +87,10 @@ export function parseOrchestrateArgs(argv) {
             a.maxSessions = parseMaxSessions(value(t));
         else if (t === '--wave')
             a.wave = value(t);
+        else if (t === '--drop')
+            a.drop.push(lotArg(value(t)));
+        else if (t === '--stop-after-current')
+            a.stopAfterCurrent = true;
         else if (t === '--continue')
             a.continue = true;
         else if (t === '--until')
@@ -366,6 +370,11 @@ export async function orchestrate(argv, io, deps) {
         throw new RafError('--watch s\'utilise avec --status');
     if (args.interval !== undefined && !args.watch)
         throw new RafError('--interval s\'utilise avec --status --watch');
+    // --drop / --stop-after-current (L79) pilotent une vague VIVANTE : ni avec --status (rien à piloter), ni --stop-after-current avec --resume (il le contredit). --resume --drop retire le lot avant de rejouer la vague arrêtée.
+    if (args.status !== undefined && (args.drop.length || args.stopAfterCurrent))
+        throw new RafError('--status ne se combine pas avec --drop / --stop-after-current');
+    if (args.resume !== undefined && args.stopAfterCurrent)
+        throw new RafError('--resume ne se combine pas avec --stop-after-current (il reprend la vague, il ne l\'arrête pas)');
     if (args.status !== undefined) {
         maxSessions(args, io); // une valeur invalide est refusée ici aussi
         if (!args.watch) {
@@ -402,8 +411,10 @@ export async function orchestrate(argv, io, deps) {
     }
     if (args.resume !== undefined)
         return resume(args, argv, io, deps, launch, today);
+    if (args.drop.length || args.stopAfterCurrent)
+        return control(args, io);
     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"]');
+        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"] | --drop projet:lot | --stop-after-current');
     const refusals = [];
     const targets = resolveTargets(args, io, refusals);
     const pre = await preflight(args, targets, io, deps, launch);
@@ -616,7 +627,7 @@ async function continueRounds(first, wave, all, store, io, deps, today, args, la
     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 });
+        const why = stopReason({ now: io.now(), until: args.untilAt, quotaHit: wave.status === 'suspended-quota', questions, streak: handedBackStreak(all), interrupted: wave.status === 'interrupted' && questions === 0, stopRequested: store.control().stopAfterCurrent, remaining });
         if (why) {
             say(`continue : arrêt — ${why}`);
             return code;
@@ -776,7 +787,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.
@@ -787,11 +798,12 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
                     freeRepo(r);
             }
         });
+        handBackDroppedQuestions(ctxs); // un lot en question retiré pendant la vague : rendu avant de fixer le statut de la vague
     }
     finally {
         forget();
         // « done » = plus rien à reprendre : une question en attente ou un lot suspendu garde la vague reprenable. Des lots suspendus parce qu'une revue a sali leur dépôt (L133), budget intact, ne sont pas un manque de budget : « interrupted », le lead nettoie puis reprend.
-        wave.status = wctx.incident ? 'interrupted' : wctx.quota.hit ? 'suspended-quota' : lots.some((l) => l.status === 'suspended') && (budget.exhausted || !wctx.dirtyRepos?.size) ? 'suspended-budget' : all.every(finished) ? 'done' : 'interrupted';
+        wave.status = wctx.incident ? 'interrupted' : wctx.quota.hit ? 'suspended-quota' : lots.some((l) => l.status === 'suspended') && (budget.exhausted || !wctx.dirtyRepos?.size) && (budget.exhausted || !store.control().stopAfterCurrent) ? 'suspended-budget' : all.every(finished) ? 'done' : 'interrupted';
         saveWave();
         release();
     }
@@ -805,6 +817,58 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
         return 3;
     return all.every((l) => l.status === 'ready') ? 0 : 1;
 }
+/** `--drop` / `--stop-after-current` (L79) : une demande écrite dans le dossier d'état de la vague vivante ; c'est elle qui la lit avant sa prochaine session. */
+function control(args, io) {
+    const flags = '--drop / --stop-after-current';
+    if (args.lots.length || args.continue || args.dryRun || args.budget !== undefined || args.answers.length)
+        throw new RafError(`${flags} ne se combinent pas avec des lots à lancer, --continue, --dry-run, --budget ou --answer`);
+    const live = liveWaves(cadenceHome()).filter((w) => w.cwd === io.cwd && (args.wave === undefined || w.wave === args.wave));
+    if (live.length === 0) {
+        io.err(`orchestrate : ${flags} : aucune vague en cours${args.wave ? ` (${args.wave})` : ''} lancée depuis ce dossier`);
+        return 2;
+    }
+    if (live.length > 1) {
+        io.err(`orchestrate : ${flags} : plusieurs vagues tournent depuis ce dossier (${live.map((w) => w.wave).join(', ')}) : précisez --wave`);
+        return 2;
+    }
+    const store = RunStore.find(io.cwd, live[0].wave);
+    if (!store) {
+        io.err(`orchestrate : ${flags} : dossier d'état de la vague ${live[0].wave} introuvable`);
+        return 2;
+    }
+    const lots = store.lots();
+    const refusals = [];
+    const keys = [];
+    for (const d of args.drop) {
+        const matches = lots.filter((l) => l.lot === d.lot && (d.project ? l.project === d.project : true));
+        const where = `${d.project ? `${d.project}:` : ''}${d.lot}`;
+        if (matches.length !== 1)
+            refusals.push(matches.length ? `--drop ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--drop ${where} : lot inconnu dans la vague ${store.id}`);
+        else if (lotFinished(matches[0]))
+            refusals.push(`--drop ${lotKey(matches[0].project, matches[0].lot)} : le lot est déjà fini (${matches[0].status})`);
+        else
+            keys.push(lotKey(matches[0].project, matches[0].lot));
+    }
+    if (refusals.length) {
+        for (const r of refusals)
+            io.err(`orchestrate : ${r}`);
+        return 2;
+    }
+    // La demande est écrite quoi qu'il arrive (le fichier est inoffensif) ; mais une vague d'avant L79 ne le lira jamais : on le dit.
+    if (!waveReadsControl(store.dir))
+        io.err(`orchestrate : ${flags} : la vague ${store.id} ne lit pas les demandes de contrôle (lancée avec une version de cadence d'avant L79) : la demande est écrite dans control.log mais cette vague ne la lira pas`);
+    for (const k of keys) {
+        store.requestDrop(k);
+        store.journal(`demande : retirer ${k} de la vague`);
+        io.out(`${k} : retrait demandé — la vague ${store.id} l'écarte avant sa prochaine session (la session en cours finit)`);
+    }
+    if (args.stopAfterCurrent) {
+        store.requestStopAfterCurrent();
+        store.journal('demande : arrêt après les sessions en cours');
+        io.out(`vague ${store.id} : arrêt demandé — les sessions en cours finissent, aucune autre ne part ; reprise par « cadence orchestrate --resume ${store.id} »`);
+    }
+    return 0;
+}
 async function resume(args, argv, io, deps, launch, today) {
     const store = typeof args.resume === 'string' ? RunStore.find(launch, args.resume) : RunStore.last(launch, { unfinished: true });
     if (!store)
@@ -838,10 +902,23 @@ async function resume(args, argv, io, deps, launch, today) {
             l.questions = [];
         }
     }
+    // --resume --drop projet:lot (L79) : le lot est retiré avant d'être rejoué — le seul moyen de retirer un lot d'une vague arrêtée, --drop seul refusant une vague qui ne tourne plus.
+    const drops = [];
+    for (const d of args.drop) {
+        const matches = lots.filter((x) => x.lot === d.lot && (d.project ? x.project === d.project : true));
+        const where = `${d.project ? `${d.project}:` : ''}${d.lot}`;
+        if (matches.length !== 1)
+            refusals.push(matches.length ? `--drop ${where} : plusieurs projets portent ce lot, précisez projet:lot` : `--drop ${where} : lot inconnu dans la vague ${wave.id}`);
+        else if (lotFinished(matches[0]))
+            refusals.push(`--drop ${lotKey(matches[0].project, matches[0].lot)} : le lot est déjà fini (${matches[0].status})`);
+        else
+            drops.push(lotKey(matches[0].project, matches[0].lot));
+    }
+    // Un lot retiré ne jouera rien : il ne subit ni le verrou du dépôt, ni le .nvmrc, ni l'arbre sale — un refus pour LUI ne doit pas faire échouer la reprise des autres.
     const live = [];
+    const removed = [];
     for (const l of lots) {
-        const finished = l.status === 'ready' || l.status === 'handed-back' || l.status === 'failed';
-        if (finished)
+        if (lotFinished(l))
             continue;
         for (const s of l.steps) {
             if (s.status !== 'running')
@@ -851,7 +928,7 @@ async function resume(args, argv, io, deps, launch, today) {
             else
                 s.status = 'interrupted';
         }
-        live.push(l);
+        (drops.includes(lotKey(l.project, l.lot)) ? removed : live).push(l);
     }
     // Comme au départ : un dépôt tenu par une autre orchestration vivante est refusé avant toute écriture.
     for (const repo of new Set(live.flatMap(lotRepoPaths))) {
@@ -869,6 +946,15 @@ async function resume(args, argv, io, deps, launch, today) {
         else
             nodes.set(l, node);
     }
+    // Tous les refus avant la moindre écriture (l'arbre sale compris) : une reprise refusée ne change pas l'état de la vague.
+    const dirty = new Set();
+    for (const repo of live.flatMap(lotRepoPaths))
+        if (!dirty.has(repo)) {
+            dirty.add(repo);
+            const d = await trackedDirty(repo);
+            if (d.length)
+                refusals.push(`${basename(repo)} : arbre sale, ${d.length} fichier(s) suivi(s) modifié(s) : ${d.join(', ')}`);
+        }
     if (refusals.length) {
         for (const r of refusals)
             io.err(`orchestrate : ${r}`);
@@ -882,7 +968,7 @@ async function resume(args, argv, io, deps, launch, today) {
     }
     // Une étape interrompue (signal, crash) dont les tokens n'ont pas été comptés : relue dans le journal de sa session.
     const recovered = new Budget(0);
-    for (const l of live)
+    for (const l of [...live, ...removed])
         for (const s of l.steps)
             if (s.status === 'interrupted')
                 countInterrupted(deps.claudeHome, l.repo, s, recovered);
@@ -897,23 +983,26 @@ async function resume(args, argv, io, deps, launch, today) {
     }
     if (args.budget !== undefined)
         wave.budget = wave.consumed + args.budget;
-    const dirty = new Set();
-    for (const repo of live.flatMap(lotRepoPaths))
-        if (!dirty.has(repo)) {
-            dirty.add(repo);
-            const d = await trackedDirty(repo);
-            if (d.length)
-                refusals.push(`${basename(repo)} : arbre sale, ${d.length} fichier(s) suivi(s) modifié(s) : ${d.join(', ')}`);
-        }
-    if (refusals.length) {
-        for (const r of refusals)
-            io.err(`orchestrate : ${r}`);
-        return 2;
+    store.clearStopRequest(); // un arrêt demandé à la vague d'avant ne doit pas arrêter celle-ci
+    for (const l of removed) {
+        const k = lotKey(l.project, l.lot);
+        store.requestDrop(k);
+        store.journal(`demande : retirer ${k} de la vague (--resume --drop)`);
+        io.out(`${k} : retrait demandé — le lot est rendu au lead sans être rejoué`);
+        l.next = null;
+        l.status = 'handed-back';
+        l.outcome = DROPPED;
+        store.writeLot(l);
+        store.journal(`${k} → handed-back — ${DROPPED}`);
     }
     if (live.length === 0) {
+        if (lots.every(lotFinished)) {
+            wave.status = 'done';
+            store.writeWave(wave);
+        }
         for (const line of renderTable(wave, lots))
             io.out(line);
-        return 0;
+        return removed.length && !lots.every((l) => l.status === 'ready') ? 1 : 0;
     }
     return continueRounds(await execute(wave, live, store, io, deps, today, maxSessions(args, io), lots), wave, lots, store, io, deps, today, args, launch);
 }

package/dist/orchestrate/continue.js

@@ -7,6 +7,7 @@ import { gitRoot } from '../git.js';
 import { findProjects, isProject } from '../lead.js';
 import { RafError } from '../plan.js';
 import { lotBudget } from './command.js';
+import { STOP_REQUESTED } from './cycle.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());
@@ -80,6 +81,8 @@ export function candidates(launch, o) {
 }
 /** Pourquoi la vague ne tire plus de lot, ou null quand elle peut continuer. */
 export function stopReason(f) {
+    if (f.stopRequested)
+        return STOP_REQUESTED;
     if (f.interrupted)
         return 'vague interrompue (incident ou signal)';
     if (f.quotaHit)

package/dist/orchestrate/cycle.js

@@ -263,8 +263,15 @@ const lotOver = (l) => l.budget !== undefined && lotSpent(l) >= l.budget;
 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;
+/** Cause d'une suspension demandée par `--stop-after-current` (L79). */
+export const STOP_REQUESTED = 'arrêt demandé (--stop-after-current)';
+/** Le lot a-t-il été écarté de la vague par `--drop` (L79) ? */
+const dropped = (c) => c.wave.store.control().drops.includes(lotKey(c.lot.project, c.lot.lot));
+export const DROPPED = 'retiré de la vague (--drop)';
 /** Pourquoi plus aucune session ne doit partir (incident, quota, budget), sinon null. */
 function halted(w, lot) {
+    if (w.store.control().stopAfterCurrent)
+        return STOP_REQUESTED;
     if (w.incident)
         return `vague arrêtée : ${w.incident}`;
     if (lot && w.dirtyRepos) {
@@ -289,6 +296,8 @@ function reviewModel(c, kind) {
 async function session(c, kind) {
     const w = c.wave;
     const l = c.lot;
+    if (dropped(c))
+        return stop(c, 'handed-back', DROPPED);
     const halt = halted(w, l);
     if (halt)
         return suspend(c, halt);
@@ -891,15 +900,46 @@ export function isNonQuestion(q) {
         return false;
     return NON_QUESTIONS.has(normalizeQuestion(q));
 }
+/** Fin de vague (L79) : un lot qui a posé sa question PENDANT la vague, puis retiré par `--drop`, n'a plus de cycle à jouer pour s'en apercevoir : il est rendu ici, sinon il resterait en question pour toujours. */
+export function handBackDroppedQuestions(ctxs) {
+    for (const c of ctxs)
+        if (c.lot.status === 'question' && dropped(c))
+            stop(c, 'handed-back', DROPPED);
+    // Les lots restés en file derrière un lot retiré ne seront jamais joués (comme le pool pour une dépendance rendue au lead) : rendus aussi, de proche en proche.
+    for (let moved = true; moved;) {
+        moved = false;
+        for (const c of ctxs) {
+            if (c.lot.steps.length || (c.lot.status !== 'queued' && c.lot.status !== 'suspended'))
+                continue;
+            const dead = (c.lot.dependsOn ?? []).filter((id) => {
+                const d = ctxs.find((o) => o.lot.project === c.lot.project && o.lot.lot === id);
+                return d?.lot.status === 'handed-back' || d?.lot.status === 'failed';
+            });
+            if (dead.length === 0)
+                continue;
+            stop(c, 'handed-back', `dépendance non prête dans la vague : ${dead.join(', ')}`);
+            moved = true;
+        }
+    }
+}
 /** Joue le cycle d'un lot jusqu'à son terme, ou jusqu'à l'arrêt (question, budget, quota). Ne lève jamais. */
 export async function runLot(c) {
     const l = c.lot;
     try {
         if (TERMINAL.has(l.status))
             return;
+        if (l.status === 'question' && dropped(c)) {
+            // Un lot en question retiré (--drop, éventuellement à la reprise) : il n'attend plus de réponse, il est rendu au lead.
+            stop(c, 'handed-back', DROPPED);
+            return;
+        }
         if (l.status === 'question' && !l.pendingAnswer)
             return;
         if (l.next === null && l.steps.length === 0) {
+            if (dropped(c)) {
+                stop(c, 'handed-back', DROPPED);
+                return;
+            }
             // Pas de raf start ni de commit du plan pour un lot qu'aucune session ne suivrait.
             const halt = halted(c.wave, l);
             if (halt) {

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/snapshot.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { chmodSync, cpSync, existsSync, mkdirSync, realpathSync, symlinkSync } from 'node:fs';
+import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, realpathSync, symlinkSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { join, sep } from 'node:path';
 import { createInterface } from 'node:readline';
@@ -75,6 +75,20 @@ export function takeSnapshot(waveDir, packageRoot) {
     return tool;
 }
 export const snapshotExists = (waveDir) => existsSync(join(toolDirOf(waveDir), 'bin', 'cadence.js'));
+/**
+ * La vague lit-elle `control.log` (`--drop`, `--stop-after-current`, L79) ? Elle tourne sur son instantané : une vague lancée
+ * avant L79 n'a pas ce code et ignorerait la demande en silence. Sans instantané (vague jouée dans ce processus, ou antérieure à L61) : rien à lire, on suppose que oui.
+ */
+export function waveReadsControl(waveDir) {
+    if (!snapshotExists(waveDir))
+        return true;
+    try {
+        return readFileSync(join(toolDirOf(waveDir), 'dist', 'orchestrate', 'state.js'), 'utf8').includes('control.log');
+    }
+    catch {
+        return false;
+    }
+}
 /** Relance réelle : un processus node sur la copie, signaux transmis, code de sortie rendu. */
 export function spawnReexec(toolDir, argv, env, sink) {
     return new Promise((resolve, reject) => {

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. */
@@ -105,6 +107,26 @@ export class RunStore {
         };
         return all.map((l, i) => ({ l, i })).sort((a, b) => rank(a.l) - rank(b.l) || a.i - b.i).map((x) => x.l);
     }
+    /** Demandes faites à une vague vivante (`--drop`, `--stop-after-current`, L79) : un fichier de lignes, en ajout seul, que la vague relit avant chaque session. Pas de `.json` : `lots()` le prendrait pour un lot. */
+    control() {
+        const f = join(this.dir, 'control.log');
+        const lines = existsSync(f) ? readFileSync(f, 'utf8').split('\n').map((l) => l.trim()) : [];
+        return { drops: lines.filter((l) => l.startsWith('drop ')).map((l) => l.slice(5)), stopAfterCurrent: lines.includes('stop-after-current') };
+    }
+    requestDrop(key) {
+        appendFileSync(join(this.dir, 'control.log'), `drop ${key}\n`);
+    }
+    requestStopAfterCurrent() {
+        appendFileSync(join(this.dir, 'control.log'), 'stop-after-current\n');
+    }
+    /** Efface l'arrêt demandé (`--resume`) ; les retraits restent. */
+    clearStopRequest() {
+        const f = join(this.dir, 'control.log');
+        if (!existsSync(f))
+            return;
+        const kept = readFileSync(f, 'utf8').split('\n').filter((l) => l.trim() !== '' && l.trim() !== 'stop-after-current');
+        writeFileSync(f, kept.map((l) => `${l}\n`).join(''));
+    }
     journal(line) {
         appendFileSync(join(this.dir, 'journal.log'), `${new Date().toISOString()} ${line}\n`);
     }

package/dist/orchestrate/table.js

@@ -1,3 +1,6 @@
+import { lotWork } from '../audit.js';
+import { planLoader } from '../config.js';
+import { isAncestor } from '../git.js';
 import { quotaReset } from './result.js';
 const k = (n) => `${Math.round(n / 1000)} k`;
 const m = (n) => `${(n / 1_000_000).toFixed(1).replace('.', ',')} M`;
@@ -38,8 +41,60 @@ function ux(l) {
 const commits = (l) => new Set(l.steps.flatMap((s) => s.commits ?? [])).size;
 const counted = (l) => l.steps.reduce((n, s) => n + (s.tokens?.counted ?? 0), 0);
 const minutes = (l) => Math.round(l.steps.reduce((n, s) => n + (s.ended ? Date.parse(s.ended) - Date.parse(s.started) : 0), 0) / 60_000);
+/** Sha abrégés (7, comme `short` du cycle) des commits que git attribue au lot dans son dépôt, du plus ancien au plus récent (illisible ou sans plan : aucun). */
+function gitCommitsOf(l) {
+    try {
+        return lotWork(planLoader(l.repo)(), l.repo, l.lot).map((c) => c.sha.slice(0, 7)).reverse();
+    }
+    catch {
+        return [];
+    }
+}
+const sameCommit = (a, b) => a.length >= 4 && b.length >= 4 && (a.startsWith(b) || b.startsWith(a));
+/**
+ * Sha des commits du lot dans son dépôt : ceux que git attribue au lot (une session en échec, au rapport illisible ou coupée
+ * par le quota n'a pas rempli `steps[].commits` ; ceux d'une vague précédente n'y sont pas), du plus ancien au plus récent,
+ * puis ceux des étapes que git n'a pas retrouvés (entrées `<sha> <sujet>` ; ceux d'un dépôt voisin, `[rel] sha`, sont écartés).
+ * Ce second groupe suit le premier sans respecter l'ordre de l'historique (git écarte les commits plan-seuls et de version, qui
+ * reviennent par les étapes) : le premier et le dernier commit s'obtiennent par ascendance (`oldest`, `newest`), pas par position.
+ */
+function own(l, fromGit) {
+    const out = [...new Set(fromGit(l))];
+    for (const c of l.steps.flatMap((s) => s.commits ?? []).filter((c) => !c.startsWith('[')).map((c) => c.split(' ')[0])) {
+        if (!out.some((o) => sameCommit(o, c)))
+            out.push(c);
+    }
+    return out;
+}
+/** Le plus récent des commits par ascendance (jamais la position) : `best` cède la place à `c` quand il en est un ancêtre. */
+function newest(repo, shas, ancestor) {
+    return shas.reduce((best, c) => (ancestor(repo, best, c) ? c : best));
+}
+/** Le plus ancien des commits par ascendance : `best` cède la place à `c` quand il en est un descendant. */
+function oldest(repo, shas, ancestor) {
+    return shas.reduce((best, c) => (ancestor(repo, c, best) ? c : best));
+}
+/**
+ * Lots empilés sur main (L76) : un lot prêt sous un lot non prêt n'est livrable que jusqu'à son dernier commit.
+ * Par dépôt, le plus haut dernier commit d'un lot prêt qui n'a aucun commit d'un lot non prêt sous lui et en a au moins un au-dessus.
+ */
+function deliverable(lots, ancestor, fromGit) {
+    const out = [];
+    const mine = new Map(lots.map((l) => [l, own(l, fromGit)]));
+    for (const repo of new Set(lots.map((l) => l.repo))) {
+        const here = lots.filter((l) => l.repo === repo);
+        const blocked = here.filter((l) => l.status !== 'ready' && mine.get(l).length > 0).map((l) => ({ lot: l, first: oldest(repo, mine.get(l), ancestor) }));
+        const ready = here.filter((l) => l.status === 'ready' && mine.get(l).length > 0).map((l) => ({ lot: l, last: newest(repo, mine.get(l), ancestor) }));
+        const ok = ready.filter((r) => blocked.every((b) => !ancestor(repo, b.first, r.last)));
+        const above = ok.map((r) => ({ ...r, under: blocked.find((b) => ancestor(repo, r.last, b.first))?.lot })).filter((r) => r.under);
+        const top = above.find((r) => above.every((o) => ancestor(repo, o.last, r.last)));
+        if (top)
+            out.push({ ready: top.lot, sha: top.last, under: top.under });
+    }
+    return out;
+}
 /** Le tableau de fin de vague (ou de `--status`), une ligne par lot puis le total et les questions. */
-export function renderTable(wave, lots) {
+export function renderTable(wave, lots, deps = {}) {
     const rows = lots.map((l) => [`${l.project}:${l.lot}`, LABEL[l.status], String(l.pass), review(l), ux(l), String(commits(l)), k(counted(l)), `${minutes(l)} min`]);
     const head = ['lot', 'état', 'passes', 'revue', 'UX', 'commits', 'tokens', 'durée'];
     const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
@@ -56,6 +111,9 @@ export function renderTable(wave, lots) {
         for (const c of l.status === 'handed-back' ? l.constats : [])
             out.push(`    · [${c.gravite}] ${c.fichier ? `${c.fichier}${c.ligne ? `:${c.ligne}` : ''} — ` : ''}${c.texte.split('\n')[0]}`);
     }
+    for (const d of deliverable(lots, deps.isAncestor ?? isAncestor, deps.lotCommits ?? gitCommitsOf)) {
+        out.push(`${d.ready.project}:${d.ready.lot} — livrable jusqu'à ${d.sha} (dernier commit de ${d.ready.lot}, sous ${d.under.lot} ${d.under.status === 'handed-back' || d.under.status === 'failed' ? 'rendu' : LABEL[d.under.status]}) : git push origin ${d.sha}:main && cadence deliver --sha ${d.sha}`);
+    }
     for (const l of lots) {
         if (l.uxNote)
             out.push(`${l.project}:${l.lot} — ${l.uxNote}`);

package/package.json

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

@@ -79,6 +79,13 @@ bring a question back at once (`--resume --answer`). That follow-up replaces any
 no `sleep`. The human can also watch from a terminal with `cadence orchestrate --status --watch` (table refreshed
 every 10 s, `--interval <s>` to change it; it stops by itself when no wave is running).
 
+**Steering a wave that is running.** From the folder the wave was launched in (`--wave <id>` when several run from it), in
+another command: `cadence orchestrate --drop <project>:<lot>` takes a lot out of the wave — a lot not started never starts, a lot
+with a session running lets that session finish, then it is handed back to the lead (its commits stay); a lot that depended on it is
+handed back too. `cadence orchestrate --stop-after-current` lets the sessions running finish and starts nothing else: the wave
+ends `interrupted`, and `--resume` takes it up again. To take a lot out of a wave that is already stopped, use
+`--resume --drop <project>:<lot>` (the lot is handed back instead of being replayed). Neither kills a session.
+
 `cadence orchestrate --dry-run …` first when a precondition is in doubt. The program, not the lead, runs
 for each lot a fresh short session per step — implementation (Sonnet), UX review if the lot is `visible`
 and the project declares how to see its app (`orchestrate.ux` in `cadence.yaml`), code review last
@@ -102,7 +109,7 @@ and do not deliver it (`cadence deliver` refuses).
 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
+`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; when the final table gives « livrable jusqu'à <sha> » for a repository — a ready lot under a handed-back one — push that sha alone with `git push origin <sha>:main`, then `cadence deliver --sha <sha>`, never HEAD, which holds the unreviewed code of the lot above), 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
@@ -152,6 +159,12 @@ lot, the chain goes on with the other lots and does not wait for it. A delivery
 One project at a time, by the lead: push, then the `deliver` skill (`cadence deliver --dry-run`, then
 `cadence deliver`). Follow the human's standing instructions about confirmation before production.
 
+When the wave's final table gives a line « livrable jusqu'à <sha> » for the repository (a ready lot stacked under a
+handed-back or failed one), HEAD holds the code of the lot above, which was not reviewed: never push or deliver HEAD.
+Push that sha alone first (`git push origin <sha>:main`), then deliver it (`cadence deliver --dry-run --sha <sha>`, then
+`cadence deliver --sha <sha>`). The push comes first because with `ci: github` the CI wait looks for the run of that exact
+sha, and GitHub only builds the tip of a push: without it, the wait ends on « no CI run for this sha ».
+
 After a green delivery that changes what a page shows or what it is served (screen, API, data
 source, configuration of either) — in practice every delivery except docs-, plan- or tests-only ones
 — have the `qa-reviewer` agent check the delivered app, as a fresh subagent: give it the absolute