@sylad/cadence 0.17.0 → 0.19.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.17.0",
+      "version": "0.19.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. No CLI needed.",
-      "version": "0.2.0",
+      "version": "0.3.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.17.0",
+  "version": "0.19.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.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.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),
@@ -414,9 +414,10 @@ URL. The agent then returns a draft for you to correct — it never writes the f
 cadence session start              # notes from the last close, lots in progress (silent ones flagged),
                                    # work done since yesterday by lot, drift, repo state, 3 proposals
 cadence session start --since "3 days ago" --idle 2
-cadence session close              # today's commits by lot, commits without a lot, lots in progress
-                                   # with no commit today, drift, uncommitted / unpushed work
-                                   # exit 1 while something is still open
+cadence session close              # commits by lot since the last `session start`,
+                                   # commits without a lot, lots in progress with no commit in that window,
+                                   # drift, uncommitted / unpushed work; exit 1 while something is still open
+cadence session close --since "2 days ago"   # --since overrides the window
 cadence session start --all        # from a folder that is not a repository: one "## project" section per
 cadence session close --all --depth 2   # sub-folder holding a plan (--depth n: n levels down, 1 by default);
                                    # exit = the worst code of the projects (2 error, 1 open, 0 closed)
@@ -424,6 +425,18 @@ cadence session next "finish L3" "review L4"    # shown by the next session star
 cadence session next --clear       # erase those notes, on purpose
 ```
 
+`session start` records its time in the worktree's state (`session.json`, under the git dir); the next
+`session close` takes it as its window and names it in the section title: `Commits de la période (depuis
+l'ouverture de 09:12)` (with the date when it is not today). A close never moves the boundary, refused
+or not: run again without a `session start` in between (the `session-close` skill does, after fixing a
+point), it still reports since that opening instead of an empty period. With no recorded opening, or an
+unreadable file, the window is the current day, said as such (`depuis 2026-09-28 00:00`); `--since` is
+quoted as given. (A `session.json` written by 0.18.0 after a close, `depuis la clôture de …`, is still read.)
+
+On success `cadence session next` prints what it recorded (`2 lignes enregistrées pour la prochaine
+ouverture`, then the lines as written, blank ones dropped), so `session-close` can report
+them without running `session start` again.
+
 `--all` runs the same command inside each project found under the current folder —
 `docs/plan/raf.yaml`, or a `cadence.yaml` with `plan:` — and never enters a project
 to look for another. `--since` and `--idle` go to every project; an error in one
@@ -492,8 +505,8 @@ An entry is proposed only if it could be measured entirely. Never proposed:
 The command deletes nothing, never fails on the cleanup and does not change the exit code: the
 `session-close` skill shows the list and removes the entries only after the human agrees.
 
-The commands get `CADENCE_SINCE` (the `--since` in effect) and `CADENCE_TODAY`. They
-add facts and decide nothing: a failing command is reported and changes neither
+The commands get `CADENCE_SINCE` and `CADENCE_TODAY`. `CADENCE_SINCE` is the `--since` as given; on `session close` without `--since` it is the instant of the last `session start` as an ISO 8601 UTC string (`2026-09-28T07:12:00.000Z`), or `<today> 00:00` when no mark exists.
+The commands add facts and decide nothing: a failing command is reported and changes neither
 the exit code nor the verdict.
 
 ## lead tour
@@ -868,7 +881,7 @@ the name `repos`). The effect, for `cadence orchestrate`:
 - **Lock and guard**: the neighbour gets the repository lock (`orchestrate.lock`, so `cadence deliver` refuses it too, and no
   other wave can hold it), the temporary `pre-push` hook, and the same after-session checks (push, tampered hook, a review
   that changed it). Two lots that share a repository, as project or as neighbour, run one after the other, never two
-  sessions in one repository; `--status` lists the neighbours among the repositories a wave holds.
+  sessions in one repository; `--status` lists the neighbours among the repositories a wave still holds (a repository released once all its lots are finished no longer appears).
 - **Sessions**: every session gets each neighbour as `--add-dir`, and the briefs name them: the implementation and the
   corrections must commit there too, with a message that cites the lot (`feat(B64): …`), and never push; the reviewers read
   the commits that cite the lot in the project **and** in each neighbour (`raf commits <lot>` lists them all; in a neighbour only the commits that cite the lot and are dated within the lot's period count, and also contain the `cite:` string when the lot declares one for it — a `fix(B64): …` outside the period, or one without the `cite:` string, is not listed.) A lot whose
@@ -887,7 +900,10 @@ verdict and screenshots, it does not record it), the push and the deliveries, on
 `orchestrate.lock`, which also makes `cadence deliver` refuse that repository), not per folder. A wave is
 refused only when one of its repositories is held by a live wave (`<repo> : une orchestration y est déjà en
 cours`; the lock of a dead process is detected and cleared); two waves on different repositories run side by
-side, even when started from the same parent folder. They share a **cap on simultaneous sessions**, counted
+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
 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
@@ -897,15 +913,15 @@ A slot or a registry entry is owned by a pid **and** its start time: a reused pi
 identifiers are reserved atomically (`-2`, `-3` suffix when two waves start in the same minute; an existing
 `--wave` is refused). The registry of live waves and the slots live under `~/.cadence/orchestrate/` (`CADENCE_HOME`
 to move it): `cadence orchestrate --status` lists, from any folder, the live waves, the repositories each
-holds, the cap of each wave and the slots in use.
+still holds (those not yet released), the cap of each wave and the slots in use.
 
 **Guards, imposed by the code**: a global cap of simultaneous sessions, one wave per repository at
 a time (above); `Agent`, `git push`, `cadence deliver`, `raf done|review|ux` are denied to the sessions; a
-temporary `pre-push` hook, installed for the duration of the wave and removed at its end, refuses any push
+temporary `pre-push` hook, installed for the duration of the wave and removed at its end (or, for a repository, as soon as all the lots that touch it are finished), refuses any push
 from a session (`CADENCE_ORCHESTRATED` is in their environment; a repository that already has another
 `pre-push` hook is refused before anything starts — `pushurl` is never touched); after every session the
 upstream ref and `git ls-remote` are compared with the "before", and a review that changed `HEAD` or the
-tree is an incident that stops the wave. `raf done|ux|review` and `cadence deliver` refuse when
+tree (screenshots left at the root, a commit) is an incident of that lot only: the lot is handed back to the lead, the lots of the other repositories carry on while the lots still queued behind it in the same repository are suspended (resumable, nothing started on a dirty tree), and a verdict the review had already produced is reported in the outcome and the lot's warnings (never recorded in the plan). A push or a removed guard hook still stops the wave. `raf done|ux|review` and `cadence deliver` refuse when
 `CADENCE_ORCHESTRATED` is set.
 
 **Budget**: the wave counts input + cache writes + output tokens (default 2 M); cache reads are kept and

package/dist/cli.js

@@ -407,7 +407,7 @@ function dispatch(argv, io) {
             const sconf = rest[0] === 'start' || rest[0] === 'close' ? readSessionConfig(configPath) : {};
             const facts = rest[0] === 'start' || rest[0] === 'close' ? sconf[rest[0]] : undefined;
             const clean = rest[0] === 'close' && sconf.clean ? { patterns: sconf.clean, days: sconf.cleanDays } : undefined;
-            const sctx = { plan: loadPlan(), root, newsDir, state: stateDir(root), shared: sharedStateDir(root), today, out: io.out, facts, clean };
+            const sctx = { plan: loadPlan(), root, newsDir, state: stateDir(root), shared: sharedStateDir(root), today, now: io.now(), out: io.out, facts, clean };
             if (rest[0] !== 'start')
                 return session(rest, sctx, values);
             // La reprise rejoue les vérifications d'effet (un essai, borné) : un effet rouge d'hier se lit avec les faits du matin.
@@ -421,7 +421,7 @@ function dispatch(argv, io) {
                 throw new RafError('deliver : à lancer dans un dépôt git');
             const orchestrating = activeLock(join(sharedStateDir(root), REPO_LOCK));
             if (orchestrating)
-                throw new RafError(`deliver : orchestration en cours (vague ${orchestrating.wave}, pid ${orchestrating.pid}) — livrer une fois la vague finie`);
+                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)`);
             const config = parseDeliverConfig(readFileSync(configPath, 'utf8'), configPath);
@@ -773,7 +773,7 @@ function session([sub, ...args], ctx, values) {
             return sessionStart(ctx, { since: values.since ?? '24 hours ago', idle });
         }
         case 'close':
-            return sessionClose(ctx, { since: values.since ?? `${ctx.today} 00:00` });
+            return sessionClose(ctx, { since: values.since });
         case 'next': {
             const lines = args.filter((l) => l.trim() !== '');
             if (values.clear) {
@@ -791,6 +791,10 @@ function session([sub, ...args], ctx, values) {
                     'usage : cadence session next "ligne" … (pour effacer les notes exprès : cadence session next --clear)');
             }
             writeNext(ctx.state, ctx.today, lines);
+            // Rien sur stdout laissait croire à un échec : on redit les lignes telles qu'enregistrées, pour que
+            // session-close les rapporte sans relancer session start.
+            const n = lines.length;
+            ctx.out(`${n} ligne${n > 1 ? 's' : ''} enregistrée${n > 1 ? 's' : ''} pour la prochaine ouverture\n${lines.map((l) => `  - ${l}`).join('\n')}`);
             return 0;
         }
         default:

package/dist/orchestrate/command.js

@@ -10,7 +10,7 @@ import { stopApps } from './app.js';
 import { Plan, RafError, isOpen } from '../plan.js';
 import { AGENTS_DIR } from '../skills.js';
 import { pidAlive, sharedStateDir } from '../state.js';
-import { acquireSlot, cadenceHome, liveSlots, liveWaves, registerWave, unregisterWave } from './registry.js';
+import { acquireSlot, cadenceHome, liveSlots, liveWaves, registerWave, unregisterWave, updateWaveRepos } from './registry.js';
 import { loadTemplates, newsText, objective, renderBrief } from './briefs.js';
 import { Budget, MAX_PASSES, countInterrupted, needsPrecheck } from './cycle.js';
 import { canInstallPrePush, installPrePush, removePrePush, snapshot } from './guard.js';
@@ -472,12 +472,28 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
     const home = cadenceHome();
     const held = [];
     const repos = [...new Set(lots.flatMap(lotRepoPaths))];
+    /** Libère un dépôt : son verrou et sa garde de push (L132 : dès que ses lots sont finis, pas à la fin de la vague). */
+    const freed = new Set();
+    const freeRepo = (r) => {
+        freed.add(r);
+        const file = join(sharedStateDir(r), REPO_LOCK);
+        releaseLock(file, process.pid);
+        held.splice(0, held.length, ...held.filter((f) => f !== file));
+        removePrePush(r, wave.id);
+        try {
+            updateWaveRepos(home, process.pid, repos.filter((x) => !freed.has(x)));
+        }
+        catch {
+            // registre illisible : `--status` garde la liste de départ, le verrou est bien tombé
+        }
+    };
     const release = () => {
         for (const f of held)
             releaseLock(f, process.pid);
         held.length = 0;
         for (const r of repos)
-            removePrePush(r, wave.id);
+            if (!freed.has(r))
+                removePrePush(r, wave.id);
         try {
             unregisterWave(home, process.pid);
         }
@@ -575,14 +591,22 @@ 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';
     try {
-        await runPool(ctxs, cap, all);
+        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.
+            if (wctx.incident)
+                return;
+            for (const r of lotRepoPaths(c.lot)) {
+                if (held.includes(join(sharedStateDir(r), REPO_LOCK)) && all.filter((l) => lotRepoPaths(l).includes(r)).every(finished))
+                    freeRepo(r);
+            }
+        });
     }
     finally {
         forget();
-        const finished = (l) => l.status === 'ready' || l.status === 'handed-back' || l.status === 'failed';
-        // « done » = plus rien à reprendre : une question en attente ou un lot suspendu garde la vague reprenable.
-        wave.status = wctx.incident ? 'interrupted' : wctx.quota.hit ? 'suspended-quota' : lots.some((l) => l.status === 'suspended') ? 'suspended-budget' : all.every(finished) ? 'done' : 'interrupted';
+        // « 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';
         saveWave();
         release();
     }

package/dist/orchestrate/cycle.js

@@ -14,7 +14,7 @@ import { capturesText, newsText, objective, renderBrief, reposText } from './bri
 import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, trackGroup, writeMcpConfig } from './launch.js';
 import { cleanPlaywrightOutput, pushed, snapshot } from './guard.js';
 import { checkShape, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, WORK_SCHEMA } from './schemas.js';
-import { lotKey, neighbourDirs } from './state.js';
+import { lotKey, lotRepoPaths, neighbourDirs } from './state.js';
 /** Passes de correction au plus, puis la main est rendue au lead. */
 export const MAX_PASSES = 2;
 export class Budget {
@@ -240,9 +240,16 @@ export const lotSpent = (l) => l.steps.reduce((n, s) => n + (s.tokens?.counted ?
 /** 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;
 /** Pourquoi plus aucune session ne doit partir (incident, quota, budget), sinon null. */
-function halted(w) {
+function halted(w, lot) {
     if (w.incident)
         return `vague arrêtée : ${w.incident}`;
+    if (lot && w.dirtyRepos) {
+        for (const r of lotRepoPaths(lot)) {
+            const by = w.dirtyRepos.get(r);
+            if (by)
+                return `dépôt ${r} sali par la revue de ${by} : à nettoyer par le lead avant de reprendre`;
+        }
+    }
     if (w.quota.hit)
         return 'quota atteint';
     if (w.budget.exhausted)
@@ -258,7 +265,7 @@ function reviewModel(c, kind) {
 async function session(c, kind) {
     const w = c.wave;
     const l = c.lot;
-    const halt = halted(w);
+    const halt = halted(w, l);
     if (halt)
         return suspend(c, halt);
     if (lotOver(l))
@@ -370,8 +377,8 @@ async function session(c, kind) {
     const others = neighbours.map((repo, i) => ({ repo, before: beforeOthers[i], after: afterOthers[i] }));
     step.headAfter = after.head ?? undefined;
     // Le dépôt du projet d'abord, puis chaque voisin : mêmes contrôles, l'incident nomme le dépôt voisin.
-    const watched = [{ where: '', before, after }, ...others.map((o) => ({ where: ` dans ${o.repo.rel}`, before: o.before, after: o.after }))];
-    for (const { where, before: b, after: a } of watched) {
+    const watched = [{ where: '', path: l.repo, before, after }, ...others.map((o) => ({ where: ` dans ${o.repo.rel}`, path: o.repo.path, before: o.before, after: o.after }))];
+    for (const { where, path, before: b, after: a } of watched) {
         if (pushed(b, a)) {
             step.status = 'failed';
             step.cause = `push détecté${where}`;
@@ -387,17 +394,35 @@ async function session(c, kind) {
             return stop(c, 'failed', `incident : ${w.incident}`);
         }
         if (!write && (b.head !== a.head || b.tracked.join() !== a.tracked.join() || b.untracked.join() !== a.untracked.join())) {
+            // Incident du LOT (L133) : la revue a laissé des traces (captures, commit), ni push ni garde supprimée — les lots des autres dépôts continuent.
             step.status = 'failed';
             step.cause = `le dépôt${where} a changé pendant une revue`;
-            w.incident = `${kind} de ${lotKey(l.project, l.lot)} a modifié le dépôt${where}`;
-            w.saveWave();
-            return stop(c, 'failed', `incident : ${w.incident}`);
+            const traces = [...trackedPaths(a).filter((f) => !trackedPaths(b).includes(f)), ...a.untracked.filter((f) => !b.untracked.includes(f))];
+            (w.dirtyRepos ??= new Map()).set(path, lotKey(l.project, l.lot));
+            const what = traces.length ? ` (${traces.join(', ')})` : b.head !== a.head ? ' (commit)' : '';
+            return stop(c, 'handed-back', `incident : ${kind} de ${lotKey(l.project, l.lot)} a modifié le dépôt${where}${what}${lostVerdict(c, kind, res.structured)}`);
         }
     }
     step.status = 'ok';
     save(c);
     return { step, report: res.structured, before, after, others };
 }
+/** Verdict d'une revue interrompue par un incident du lot : rapporté au lead plutôt que perdu (L133). Rien n'est enregistré dans le plan. */
+function lostVerdict(c, kind, report) {
+    if (kind === 'precheck')
+        return '';
+    let rep;
+    try {
+        rep = checkShape(report, REVIEW_SCHEMA);
+    }
+    catch {
+        return ' ; la revue n\'a pas rendu de verdict exploitable';
+    }
+    const s = summarize(rep, '');
+    const text = `verdict de la revue avant l'incident : ${s.conforme ? 'conforme' : 'non conforme'} (${s.bloquants} bloquant(s), ${s.majeurs} majeur(s), ${s.mineurs} mineur(s)) — « ${s.verdict} » — non enregistré dans le plan, à confirmer par le lead`;
+    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) {
     const l = c.lot;
@@ -657,7 +682,7 @@ async function review(c, kind) {
     const ux = c.config.ux;
     if (!ux?.command || !ux.url || !seesApp(l, kind))
         return reviewStep(c, kind);
-    const halt = halted(c.wave);
+    const halt = halted(c.wave, l);
     if (halt) {
         suspend(c, halt); // la session n'aurait pas lieu : l'application ne se lance pas pour rien
         return;
@@ -841,7 +866,7 @@ export async function runLot(c) {
             return;
         if (l.next === null && l.steps.length === 0) {
             // Pas de raf start ni de commit du plan pour un lot qu'aucune session ne suivrait.
-            const halt = halted(c.wave);
+            const halt = halted(c.wave, l);
             if (halt) {
                 suspend(c, halt);
                 return;

package/dist/orchestrate/pool.js

@@ -6,9 +6,9 @@ export const SLOTS = 2;
  * Ordonnanceur : une file par dépôt, les lots d'un dépôt l'un après l'autre dans l'ordre donné, `slots` dépôts
  * au plus en parallèle. Deux lots qui partagent un dépôt (le leur, ou un dépôt voisin déclaré par `repos:`, L62) sont dans la
  * même file : jamais deux sessions dans un même dépôt (le plafond global des sessions de toutes
- * les vagues est tenu par command.ts). Le budget, le quota et les incidents sont vérifiés par le cycle avant chaque session.
+ * les vagues est tenu par command.ts). `onSettled` est appelé quand un lot a fini de jouer (L132 : command.ts libère alors les dépôts que plus aucun lot ne tient). Le budget, le quota et les incidents sont vérifiés par le cycle avant chaque session.
  */
-export async function runPool(ctxs, slots = SLOTS, known = []) {
+export async function runPool(ctxs, slots = SLOTS, known = [], onSettled = () => { }) {
     const groups = [];
     for (const c of ctxs) {
         const mine = lotRepoPaths(c.lot);
@@ -51,12 +51,14 @@ export async function runPool(ctxs, slots = SLOTS, known = []) {
                         c.wave.store.writeLot(c.lot);
                         c.wave.log(`${lotKey(c.lot.project, c.lot.lot)} → handed-back — ${c.lot.outcome}`);
                         progress = true;
+                        onSettled(c);
                         continue;
                     }
                     if (c.lot.outcome?.startsWith('en attente de : '))
                         c.lot.outcome = null;
                     progress = true;
                     await runLot(c);
+                    onSettled(c);
                 }
                 todo = waiting;
             }

package/dist/orchestrate/registry.js

@@ -59,6 +59,15 @@ export function registerWave(home, given) {
     writeFileSync(`${file}.tmp`, JSON.stringify(w));
     renameSync(`${file}.tmp`, file);
 }
+/** Met à jour la liste des dépôts tenus par la vague (un dépôt libéré en cours de vague n'y figure plus). */
+export function updateWaveRepos(home, pid, repos) {
+    const file = join(wavesDir(home), `${pid}.json`);
+    const w = readWave(file);
+    if (!w)
+        return;
+    writeFileSync(`${file}.tmp`, JSON.stringify({ ...w, repos }));
+    renameSync(`${file}.tmp`, file);
+}
 export function unregisterWave(home, pid) {
     rmSync(join(wavesDir(home), `${pid}.json`), { force: true });
 }

package/dist/session.js

@@ -5,7 +5,7 @@ import { audit, exemptPlanOnly, nextUp, planCommits } from './audit.js';
 import { diffDays, maxDay } from './dates.js';
 import { repoStatus } from './git.js';
 import { linkCommits } from './link.js';
-import { lockAlive, readLock, readNext } from './state.js';
+import { lockAlive, readLock, readNext, readSessionMark, writeSessionMark } from './state.js';
 const FACTS_TIMEOUT = 120_000;
 /**
  * Sortie de la commande du projet, ligne à ligne. Un échec se dit et ne bloque rien : ce sont des
@@ -81,6 +81,23 @@ export function lastActivity(lot, commits) {
     const days = [commits[0]?.day, lot.started, ...lot.notes.map((n) => n.date)].filter((d) => !!d);
     return days.length ? days.reduce(maxDay) : undefined;
 }
+const hhmm = (d) => `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
+/**
+ * Fenêtre de la clôture : --since s'il est donné ; sinon depuis la dernière ouverture du
+ * projet, dite avec son heure ; sinon le jour même.
+ */
+function closeWindow(ctx, since) {
+    if (since !== undefined)
+        return { since, label: `depuis ${since}` };
+    const mark = readSessionMark(ctx.state);
+    if (!mark)
+        return { since: `${ctx.today} 00:00`, label: `depuis ${ctx.today} 00:00` };
+    const at = new Date(mark.at);
+    const what = mark.kind === 'start' ? "l'ouverture" : 'la clôture';
+    const sameDay = at.toDateString() === (ctx.now ?? new Date()).toDateString();
+    const when = sameDay ? `de ${hhmm(at)}` : `du ${at.getFullYear()}-${String(at.getMonth() + 1).padStart(2, '0')}-${String(at.getDate()).padStart(2, '0')} à ${hhmm(at)}`;
+    return { since: mark.at, label: `depuis ${what} ${when}` };
+}
 export function sessionStart(ctx, opts) {
     const { plan, out, today } = ctx;
     const lots = plan.lots();
@@ -117,17 +134,20 @@ export function sessionStart(ctx, opts) {
         ...ready.map((l) => ({ l, why: l.quickwin ? 'gain rapide prêt' : 'prêt' })),
     ].slice(0, 3);
     section(out, 'Propositions', proposals.map(({ l, why }, i) => `${i + 1}. ${l.quickwin ? '⚡ ' : ''}${l.id}  ${l.title} — ${why}`));
+    // La clôture du soir part de cette heure : elle ne relit pas ce que l'ouverture vient de rapporter.
+    writeSessionMark(ctx.state, { kind: 'start', at: (ctx.now ?? new Date()).toISOString() });
     return 0;
 }
 export function sessionClose(ctx, opts) {
     const { plan, out, today } = ctx;
     out(`${plan.project} — clôture du ${today}`);
-    const recent = period(ctx, opts.since);
+    const window = closeWindow(ctx, opts.since);
+    const recent = period(ctx, window.since);
     const commits = byLotLines(recent);
     if (recent.orphans.length) {
         commits.push(`${recent.orphans.length} commit(s) sans lot :`, ...recent.orphans.map((c) => `  ${short(c)}`));
     }
-    section(out, 'Commits de la période', commits.length ? commits : ['(aucun)']);
+    section(out, `Commits de la période (${window.label})`, commits.length ? commits : ['(aucun)']);
     const quiet = plan.lots().filter((l) => l.status === 'doing' && !isRecurring(l) && !recent.byLot.has(l.id));
     section(out, 'Lots en cours', quiet.map((l) => `${l.id}  ${l.title} — aucun commit sur la période : ${plan.readonly ? "le fermer ou l'annoter avec l'outil du projet" : 'raf done ou raf note'}`));
     const issues = audit(plan, ctx.root, ctx.newsDir, today);
@@ -135,7 +155,7 @@ export function sessionClose(ctx, opts) {
     const repo = repoLine(ctx.root);
     const lock = lockStatus(ctx.shared);
     section(out, 'Dépôt', [repo.line, ...(lock ? [lock.line] : [])]);
-    section(out, 'Faits propres au projet', projectFacts(ctx, opts.since));
+    section(out, 'Faits propres au projet', projectFacts(ctx, window.since));
     // Une proposition, pas une condition : rien n'est supprimé ici, le skill demande l'accord. Le
     // nettoyage ne change jamais le verdict et ne fait jamais tomber la clôture.
     if (ctx.clean?.patterns.length) {
@@ -154,5 +174,7 @@ export function sessionClose(ctx, opts) {
     }
     const open = issues.filter((i) => !i.warning).length + repo.open + (lock?.live ? 1 : 0);
     out(open === 0 ? '\n✓ prêt à fermer' : `\n✗ pas fermé : ${open} point(s)`);
+    // La clôture ne déplace jamais la borne : relancée sans ouverture entre-temps (le skill la relance exprès),
+    // elle rapporte encore depuis l'ouverture. Seule une ouverture pose la marque.
     return open === 0 ? 0 : 1;
 }

package/dist/state.js

@@ -33,6 +33,21 @@ export function clearNext(dir) {
     rmSync(join(dir, 'next.md'), { force: true });
     return previous;
 }
+/** Dernière ouverture ou clôture réussie du projet ; null si inconnue ou illisible (la clôture retombe alors sur le jour même). */
+export function readSessionMark(dir) {
+    try {
+        const raw = JSON.parse(readFileSync(join(dir, 'session.json'), 'utf8'));
+        if ((raw.kind === 'start' || raw.kind === 'close') && typeof raw.at === 'string' && !Number.isNaN(Date.parse(raw.at)))
+            return { kind: raw.kind, at: raw.at };
+    }
+    catch {
+        // absent ou illisible : pas de borne connue
+    }
+    return null;
+}
+export function writeSessionMark(dir, mark) {
+    writeFileSync(join(dir, 'session.json'), `${JSON.stringify(mark)}\n`);
+}
 export function lockPath(dir) {
     return join(dir, 'deliver.lock');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylad/cadence",
-  "version": "0.17.0",
+  "version": "0.19.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/session-close/SKILL.md

@@ -18,7 +18,7 @@ With no project named, run `cadence session close --all` from the parent folder,
 
 ## Steps
 
-1. Run `cadence session close` (over several days: `--since "2 days ago"`). Exit code 1 means
+1. Run `cadence session close` (the window runs from the last `session start`, even when the close is re-run, and is named in the "Commits de la période" title; over several days: `--since "2 days ago"`). Exit code 1 means
    *not closed*: something below is still open.
 2. **Plan hygiene**, lot by lot:
    - a `doing` lot with no commit in the period → `raf done <id>` if its tests are green,
@@ -67,7 +67,7 @@ With no project named, run `cadence session close --all` from the parent folder,
    these steps say `raf`.
 6. **Clean state**: everything committed and pushed, no delivery running. If the command still exits 1,
    say what remains and do NOT say the session is closed.
-7. **Three lines for next time**: `cadence session next "…" "…" "…"` — the next `session-start` shows them.
+7. **Three lines for next time**: `cadence session next "…" "…" "…"` — the next `session-start` shows them. The command prints the lines as recorded: report them from that output, do not run `session start` again.
    The lines replace the previous notes. Without a line the command refuses and keeps them; erase
    them on purpose with `cadence session next --clear`, only when nothing is left to say.