@sylad/cadence 0.16.0 → 0.18.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.16.0",
+      "version": "0.18.0",
       "source": "./",
       "author": {
         "name": "Sylvain Ladoire"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cadence",
   "description": "A repo-native working method: session start and close rituals driven by a versioned plan (raf), deliveries proven by their effect, and three reviewer agents (UX, code, QA).",
-  "version": "0.16.0",
+  "version": "0.18.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.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.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` (or last successful close),
+                                   # 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,17 @@ 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), and a
+`session close` that ends with `✓ prêt à fermer` records its own. The next close takes the later one
+as its window and names it in the section title: `Commits de la période (depuis l'ouverture de 09:12)`
+(`depuis la clôture de …`; with the date when it is not today). With no recorded time, 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 refused close (exit 1) leaves the boundary alone.
+
+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 +504,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 open or successful close 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
@@ -1100,14 +1112,14 @@ repository with `cadence skills install` (to `.claude/skills/cadence-*` and
 A band above the Claude Code prompt (terminal and desktop app), refreshed every 5 s:
 
 ```
-ctx ▰▰▰▰▱▱▱▱▱▱  42 % 84k/200k  │  5h  23 % ↻ 2 h 10  │  7j  61 % ↻ 6 j 15 h  │  $1.23  │  fable 410k sonnet 85k  │  ⚙ 2 agents
+ctx ▰▰▰▰▱▱▱▱▱▱  42 % 84k/200k  │  5h  23 % ↻ 2 h 10  │  7j  61 % ↻ 6 j 15 h  │  $1.23  │  fable 410k sonnet 85k  │  ⚙ 2 agents  │  2 cmd
 ⟳ cadence · 2026-10-07-2131 en cours  │  budget ▱▱▱▱▱▱▱▱▱▱   1 % 14k/2M  │  1 session/2
   L112  implémente  implement@sonnet 34 s         global-setup coupe le cache de compilation de Node...
 ```
 
 Context of the session (green / orange / red at 50 and 75 %), the 5-hour and 7-day quota
 windows with the time to their reset, the cost of the session and its split per model, the
-subagents of this session, and every live `cadence orchestrate` wave: budget, sessions, one
+subagents of this session, the background commands in progress (`2 cmd`: Bash run in the background and Monitor, subagents' included, as the app's "background commands" card counts them), and every live `cadence orchestrate` wave: budget, sessions, one
 aligned line per active lot (status, step, model, elapsed, start of the title), the lots still
 waiting. When no wave is running, the last finished one stays on a grey line until the next
 starts. Waves are read from disk (`~/.cadence/orchestrate/waves/`, then `.cadence/runs/`); no

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.
@@ -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/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 (ou clôture réussie) 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,8 @@ 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)`);
+    // Seule une clôture réussie devient la borne : relancer la clôture après avoir réglé un point ne vide pas le rapport.
+    if (open === 0)
+        writeSessionMark(ctx.state, { kind: 'close', at: (ctx.now ?? new Date()).toISOString() });
     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.16.0",
+  "version": "0.18.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` or successful close 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.