@sylad/cadence 0.14.0 → 0.15.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.14.0",
+      "version": "0.15.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.14.0",
+  "version": "0.15.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.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.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),
@@ -99,7 +99,30 @@ raf gantt                         # docs/plan/gantt.html
 | `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 gantt [-o file]` | standalone Gantt page |
-| `raf hook install` | add the (non-blocking, read-only) post-commit hook |
+| `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) |
+
+#### A commit on a lot that is still `todo`
+
+By default the post-commit hook only warns (`L1 est encore todo — raf start L1`). The `hook.autostart`
+key of `cadence.yaml` changes what the **pre-commit** hook does when the message cites a `todo` lot
+(a recurring lot, a lot already `doing`, a commit without a lot and a plan-upkeep commit are never concerned):
+
+```yaml
+hook:
+  autostart: refuse   # warn (default) | refuse | start
+```
+
+- `warn`: today's behaviour, the commit goes through, the post-commit hook warns.
+- `refuse`: the commit fails, loudly, with `raf start <id>` in the message (`--no-verify` still bypasses it).
+- `start`: the hook runs `raf start <id>` and stages the plan, so the plan change is **in the same commit** —
+  no amend afterwards, no dirty plan left behind. Only when `docs/plan/raf.yaml` is identical to `HEAD` (no
+  uncommitted change to the plan, staged or not): otherwise nothing is started, the hook says why
+  (`plan modifié non commité : démarrage automatique sauté, raf start <id> à la main`) and behaves like `warn`.
+
+The pre-commit hook reads the message from the command line of the `git commit` that runs it (`-m`, `-am`,
+`--message`, `-F`; Linux, through `/proc`) or from `CADENCE_COMMIT_MESSAGE`. When the message is not known yet
+(editor, `--amend`) it does nothing and the post-commit warning stays. Run `raf hook install` again to add the
+pre-commit block to an existing repository. A read-only plan is never started by the hook. Only a refusal (exit code 3 of `raf hook pre-commit`) stops a commit: an older or broken `raf` lets it through.
 
 Global options: `--file path` or `RAF_FILE`; `RAF_TODAY=YYYY-MM-DD` to freeze
 the date. `cadence raf …` is the same as `raf …`.
@@ -387,10 +410,21 @@ 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 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)
 cadence session next "finish L3" "review L4"    # shown by the next session start; replaces the previous notes
 cadence session next --clear       # erase those notes, on purpose
 ```
 
+`--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
+project is printed in its section and the others still run. It replaces the shell
+loop over the sub-folders. A project that is not the root of its own git repository gets a `✗` line
+(and exit 2) instead of the parent repository's plan. `--all` and `--depth` are refused outside `session`,
+and `--all` refuses `--file`, `--config` and `RAF_FILE`: each project reads its own plan. For a one-line-per-project overview, `cadence lead tour`.
+
 `cadence session next` without a line refuses (exit 2) and leaves the notes of the
 last close as they are — it used to erase them silently; erasing is `--clear`.
 

package/bin/cadence.js

@@ -26,6 +26,7 @@ if (tool === 'raf') {
   cadence session start [--since "24 hours ago"] [--idle 2]
                     faits de reprise : notes de la veille, en cours, fait depuis, écarts, propositions
   cadence session close [--since …]    faits de clôture ; code 1 tant que ce n'est pas fermé
+  cadence session start|close --all [--depth 1]   depuis un dossier non dépôt : une section par projet des sous-dossiers
   cadence session next "ligne" …       notes pour la prochaine session (remplacent les précédentes)
   cadence session next --clear         efface ces notes ; sans ligne ni --clear, la commande refuse
   cadence deliver [--dry-run] [--sha rév] [--config cadence.yaml] [-- arguments du script du projet]

package/dist/audit.js

@@ -13,7 +13,7 @@ function configRel(plan, root) {
     return plan.configFile ? relative(root, plan.configFile) : 'cadence.yaml';
 }
 /** Le plan, sa page Gantt, la configuration lue (cadence.yaml) et les fichiers tenus avec lui (plan.files). */
-function ownFiles(plan, root) {
+export function ownFiles(plan, root) {
     return new Set([relative(root, plan.path), relative(root, join(dirname(plan.path), 'gantt.html')), configRel(plan, root), ...plan.maintained]);
 }
 function withoutPlanKey(text) {

package/dist/cli.js

@@ -1,22 +1,22 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { basename, dirname, join, resolve } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
-import { readNewsConfig, readPlanConfig, readSessionConfig } from './config.js';
-import { audit, exemptPlanOnly, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
+import { readHookConfig, readNewsConfig, readPlanConfig, readSessionConfig } from './config.js';
+import { audit, exemptPlanOnly, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
 import { short } from './check.js';
 import { isDay, toDay } from './dates.js';
 import { deliver, parseDeliverConfig, realDeps } from './deliver.js';
 import { defaultTarget, effectLines, realCheckDeps, verifyCommand } from './verify.js';
 import { ganttData, renderGantt } from './gantt.js';
-import { gitRoot, readCommits, resolveCommit } from './git.js';
-import { installHook } from './hook.js';
+import { gitRoot, readCommits, matchesHead, resolveCommit, stage, stagedFiles, syncIndexWithHead } from './git.js';
+import { installHook, pendingCommitMessage, REFUSED } from './hook.js';
 import { citedRefs, linkCommits } from './link.js';
 import { buildNews, loadEntries, newEntry, newsData, newsIssues, publicTitleTooLong, stampEntries } from './news.js';
 import { Plan, RafError, STATUSES } from './plan.js';
 import { dueLine, isRecurring, recurringByDue } from './recurring.js';
 import { schedule } from './schedule.js';
 import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.js';
-import { leadTour, tourLine } from './lead.js';
+import { findProjects, leadTour, tourLine } from './lead.js';
 import { orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
 import { activeLock, REPO_LOCK } from './orchestrate/lock.js';
 import { sessionClose, sessionStart } from './session.js';
@@ -40,7 +40,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf check [--since date] [--idle 7]   (défaut : date « since » du plan) code 1 s'il y a des écarts
   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
+  raf hook install      (pre-commit et post-commit ; cadence.yaml hook.autostart: warn|refuse|start)
   cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--dry-run] [--wave nom]   une session claude neuve par étape ; --status [vague] [--watch [--interval s]] ; --resume [vague] [--budget 1M] [--answer projet:lot "réponse"]
   cadence lead tour [dossier] [--idle 3] [--json]   le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan (en cours, dérive, notes de clôture, prochain lot prêt, dépôt)
   cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
@@ -114,6 +114,8 @@ function dispatch(argv, io) {
             status: { type: 'string' },
             since: { type: 'string' },
             idle: { type: 'string' },
+            all: { type: 'boolean' },
+            depth: { type: 'string' },
             output: { type: 'string', short: 'o' },
             config: { type: 'string' },
             'dry-run': { type: 'boolean' },
@@ -131,6 +133,8 @@ function dispatch(argv, io) {
         io.out(HELP);
         return 0;
     }
+    if (command !== 'session' && (values.all || values.depth !== undefined))
+        throw new RafError(`${values.all ? '--all' : '--depth'} ne va qu'avec session start ou session close`);
     const today = io.env.RAF_TODAY ?? toDay(io.now());
     if (!isDay(today))
         throw new RafError(`RAF_TODAY invalide : ${today} (attendu AAAA-MM-JJ)`);
@@ -155,6 +159,9 @@ function dispatch(argv, io) {
                 io.out(tourLine(r));
         return 0;
     }
+    // --all balaie les sous-dossiers : il ne lit ni le plan ni le cadence.yaml du dossier courant.
+    if (command === 'session' && (values.all || values.depth !== undefined))
+        return sessionAll(rest, values, io);
     // cadence.yaml peut dire où est le plan et, s'il est tenu par un autre outil, comment le lire.
     const configPath = resolve(io.cwd, values.config ?? join(root, 'cadence.yaml'));
     // Installer les skills ou le hook ne lit pas le plan : un cadence.yaml fautif ne doit pas l'empêcher.
@@ -383,8 +390,10 @@ function dispatch(argv, io) {
                 return 0;
             }
             if (rest[0] === 'post-commit')
-                return postCommit(existsSync(planPath) ? loadPlan : null, newsDir, root, today, io);
-            throw new RafError('usage : raf hook install|post-commit');
+                return postCommit(existsSync(planPath) ? loadPlan : null, newsDir, root, today, io, readHookConfig(configPath).autostart);
+            if (rest[0] === 'pre-commit')
+                return preCommit(existsSync(planPath) ? loadPlan : null, readHookConfig(configPath).autostart, root, today, io);
+            throw new RafError('usage : raf hook install|pre-commit|post-commit');
         }
         case 'session': {
             if (!gitRoot(io.cwd))
@@ -535,11 +544,66 @@ function now(plan, root, newsDir, today, io) {
         io.out(`\n${issues.length} écart(s) entre le plan et l'historique — raf check`);
     return 0;
 }
-function postCommit(load, newsDir, root, today, io) {
+/**
+ * Pre-commit : un commit qui cite un lot encore todo. `warn` (défaut) : rien ici, le post-commit avertit ; `refuse` :
+ * échoue (REFUSED) avec « raf start <id> » ; `start` : démarre le lot et met le plan dans l'index, donc dans CE commit,
+ * mais seulement si le plan est identique à HEAD : sinon rien n'est démarré (message, puis avertissement du post-commit).
+ * Ne rend REFUSED que pour un refus : toute autre panne laisse le commit passer. Sans message lisible (éditeur), rien.
+ */
+function preCommit(load, mode, root, today, io) {
+    if (!load || !mode || mode === 'warn')
+        return 0;
+    try {
+        const message = pendingCommitMessage(io.env);
+        if (message === null)
+            return 0;
+        const plan = load();
+        const [subject = '', ...body] = message.split('\n');
+        const refs = citedRefs({ sha: '', day: today, subject, body: body.join('\n').trim() }, plan.refs);
+        const staged = stagedFiles(root);
+        const own = ownFiles(plan, root);
+        // Entretien du plan : tous les fichiers du commit sont ceux du plan (la configuration seule ne compte pas).
+        if (staged.length > 0 && staged.every((f) => own.has(f) && f !== relative(root, plan.configFile ?? join(root, 'cadence.yaml'))))
+            return 0;
+        const todo = [...new Set(refs.map((r) => r.lot))].filter((id) => {
+            const lot = plan.lots().find((l) => l.id === id);
+            return lot?.status === 'todo' && !isRecurring(lot);
+        });
+        if (todo.length === 0)
+            return 0;
+        if (mode === 'refuse') {
+            for (const id of todo)
+                io.err(`raf: ${id} est encore todo — commit refusé (hook.autostart: refuse)${plan.readonly ? '' : ` : raf start ${id}`} (--no-verify pour passer outre)`);
+            return REFUSED;
+        }
+        if (plan.readonly)
+            return 0;
+        const file = relative(root, plan.path);
+        // Un plan déjà modifié (stagé ou non) : le restager emporterait ces modifications dans ce commit, ou, sur un
+        // commit partiel, les perdrait. On ne démarre rien ; le post-commit avertit comme en mode warn.
+        if (!matchesHead(root, file)) {
+            io.err(`raf: plan modifié non commité : démarrage automatique sauté (hook.autostart: start), raf start ${todo.join(' ')} à la main`);
+            return 0;
+        }
+        for (const id of todo) {
+            plan.setStatus(id, 'doing', today, {});
+            io.err(`raf: ${id} était todo — raf start ${id} fait par le hook, plan inclus dans ce commit`);
+        }
+        plan.save();
+        stage(root, file);
+    }
+    catch {
+        // Un hook ne doit jamais gêner un commit, hors refus.
+    }
+    return 0;
+}
+function postCommit(load, newsDir, root, today, io, mode) {
     if (!load)
         return 0;
     try {
         const plan = load();
+        if (mode === 'start' && !plan.readonly)
+            syncIndexWithHead(root, relative(root, plan.path));
         const head = readCommits(root, { range: '-1' })[0];
         if (!head)
             return 0;
@@ -646,6 +710,50 @@ function morningEffects(configPath, root) {
         return [`✗ ${e.message}`];
     }
 }
+/** `session start|close --all [--depth n]` : la commande jouée dans chaque projet sous le dossier courant, une section par projet. */
+async function sessionAll(rest, values, io) {
+    const sub = rest[0];
+    if (!values.all)
+        throw new RafError('--depth demande --all');
+    // Chaque projet lit son propre plan : un plan ou une config imposés se retrouveraient dans toutes les sections.
+    const imposed = values.file !== undefined ? '--file' : values.config !== undefined ? '--config' : io.env.RAF_FILE !== undefined ? 'RAF_FILE' : null;
+    if (imposed)
+        throw new RafError(`${imposed} ne va pas avec --all : chaque projet lit son propre plan (lancer la commande dans le projet visé)`);
+    if (sub !== 'start' && sub !== 'close')
+        throw new RafError('--all ne va qu\'avec session start ou session close');
+    const depth = values.depth === undefined ? 1 : Number(values.depth);
+    if (!Number.isInteger(depth) || depth < 1)
+        throw new RafError(`--depth invalide : ${values.depth} (un entier ≥ 1)`);
+    if (values.idle !== undefined && !(Number.isInteger(Number(values.idle)) && Number(values.idle) >= 0))
+        throw new RafError(`--idle invalide : ${values.idle}`);
+    const projects = findProjects(io.cwd, depth);
+    if (projects.length === 0) {
+        io.out(`aucun projet sous ${io.cwd} (docs/plan/raf.yaml ou cadence.yaml avec plan:)`);
+        return 0;
+    }
+    const argv = ['session', sub, ...(values.since === undefined ? [] : [`--since=${values.since}`]), ...(values.idle === undefined ? [] : ['--idle', values.idle])];
+    let worst = 0;
+    for (const dir of projects) {
+        io.out(`${dir === projects[0] ? '' : '\n'}## ${relative(io.cwd, dir)}`);
+        let code;
+        const top = gitRoot(dir);
+        if (top && realpathSync(top) !== realpathSync(dir)) {
+            // run() lirait le plan du dépôt parent : mieux vaut le dire que montrer le plan d'un autre projet.
+            io.out(`✗ ${relative(io.cwd, dir)} n'a pas son propre dépôt git (dépôt parent : ${top}) — lancer cadence dans ce dossier`);
+            worst = 2;
+            continue;
+        }
+        try {
+            code = await run(argv, { ...io, cwd: dir, err: (l) => io.out(`✗ ${l}`) });
+        }
+        catch (e) {
+            io.out(`✗ ${e instanceof Error ? e.message : String(e)}`);
+            code = 2;
+        }
+        worst = Math.max(worst, code);
+    }
+    return worst;
+}
 function session([sub, ...args], ctx, values) {
     switch (sub) {
         case 'start': {
@@ -676,6 +784,6 @@ function session([sub, ...args], ctx, values) {
             return 0;
         }
         default:
-            throw new RafError('usage : cadence session start [--since …] [--idle 2] | close [--since …] | next "ligne" … | next --clear');
+            throw new RafError('usage : cadence session start [--since …] [--idle 2] | close [--since …] | start|close --all [--depth n] | next "ligne" … | next --clear');
     }
 }

package/dist/config.js

@@ -141,6 +141,33 @@ export function readNewsConfig(file) {
         throw new RafError(`${file} : news.publicTitleMax : nombre entier de caractères (≥ 1) attendu`);
     return { publicTitleMax: max };
 }
+const AUTOSTART = ['warn', 'refuse', 'start'];
+/** Clé `hook:` de cadence.yaml. */
+export function readHookConfig(file) {
+    if (!existsSync(file))
+        return {};
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const h = raw?.hook;
+    if (h == null)
+        return {};
+    if (!isObject(h))
+        throw new RafError(`${file} : hook doit être un objet { autostart }`);
+    for (const k of Object.keys(h))
+        if (k !== 'autostart')
+            throw new RafError(`${file} : hook.${k} inconnu (attendu : autostart)`);
+    const a = h.autostart;
+    if (a == null)
+        return {};
+    if (typeof a !== 'string' || !AUTOSTART.includes(a))
+        throw new RafError(`${file} : hook.autostart : ${AUTOSTART.join(', ')} attendu`);
+    return { autostart: a };
+}
 /**
  * Clé `session:` de cadence.yaml : les faits propres au projet (son script de reprise, de clôture),
  * joués par cadence au lieu d'être remplacés.

package/dist/git.js

@@ -45,6 +45,44 @@ export function hooksDir(cwd) {
     const dir = resolve(cwd, git(cwd, ['rev-parse', '--git-path', 'hooks']).trim());
     return basename(dir) === '_' && basename(dirname(dir)) === '.husky' ? dirname(dir) : dir;
 }
+/** Fichiers de l'index (ce que le commit en préparation contient), relatifs à la racine du dépôt. */
+export function stagedFiles(cwd) {
+    return git(cwd, ['-c', 'core.quotepath=off', 'diff', '--cached', '--name-only', '-z']).split('\0').filter(Boolean);
+}
+/** Ajoute un fichier à l'index. */
+export function stage(cwd, file) {
+    git(cwd, ['add', '--', file]);
+}
+/** Le fichier de travail est-il identique à sa version de HEAD (ni modification stagée, ni non stagée) ? Faux s'il n'est pas dans HEAD. */
+export function matchesHead(cwd, file) {
+    try {
+        git(cwd, ['cat-file', '-e', `HEAD:${file}`]);
+        git(cwd, ['diff', '--quiet', 'HEAD', '--', file]);
+        git(cwd, ['diff', '--quiet', '--cached', 'HEAD', '--', file]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Aligne l'index sur HEAD pour `file` quand le fichier de travail est déjà celui de HEAD : un commit partiel
+ * (`git commit <chemins>`) ne recopie dans l'index réel que ces chemins, et y laisse l'ancienne version du fichier
+ * stagé par un pre-commit. Sans effet si le fichier a d'autres modifications.
+ */
+export function syncIndexWithHead(cwd, file) {
+    const same = (args) => {
+        try {
+            git(cwd, ['diff', '--quiet', ...args, '--', file]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (same(['HEAD']) && !same(['--cached']))
+        stage(cwd, file);
+}
 /** Fichiers modifiés par un commit, relatifs à la racine du dépôt (noms accentués ou à espaces compris). */
 export function changedFiles(cwd, sha) {
     // -z : noms séparés par NUL, jamais échappés ; quotepath=off en plus pour les sorties qui citeraient quand même.

package/dist/hook.js

@@ -4,17 +4,29 @@ import { hooksDir } from './git.js';
 import { RafError } from './plan.js';
 const BEGIN = '# >>> raf (cadence)';
 const END = '# <<< raf (cadence)';
-const BLOCK = `${BEGIN}\ncommand -v raf >/dev/null 2>&1 && raf hook post-commit || true\n${END}\n`;
-/** Adds the raf block to post-commit without touching anything else already there. */
+/** Code de sortie de `raf hook pre-commit` qui refuse le commit. */
+export const REFUSED = 3;
+const BLOCKS = {
+    'post-commit': `${BEGIN}\ncommand -v raf >/dev/null 2>&1 && raf hook post-commit || true\n${END}\n`,
+    // Seul un refus (hook.autostart: refuse, code 3) arrête le commit : un raf plus ancien ou en panne le laisse passer.
+    'pre-commit': `${BEGIN}\nif command -v raf >/dev/null 2>&1; then raf hook pre-commit; [ $? -ne ${REFUSED} ] || exit 1; fi\n${END}\n`,
+};
+/** Adds the raf blocks to post-commit and pre-commit without touching anything else already there. */
 export function installHook(cwd) {
+    const post = installBlock(cwd, 'post-commit');
+    const pre = installBlock(cwd, 'pre-commit');
+    return { path: post.path, changed: post.changed || pre.changed };
+}
+function installBlock(cwd, name) {
+    const BLOCK = BLOCKS[name];
     const dir = hooksDir(cwd);
     mkdirSync(dir, { recursive: true });
-    const path = join(dir, 'post-commit');
+    const path = join(dir, name);
     const current = existsSync(path) ? readFileSync(path, 'utf8') : '';
     if (current.includes(BEGIN))
         return { path, changed: false };
     if (current !== '' && !/^#!.*\b(sh|bash|zsh|dash)\b/.test(current)) {
-        throw new RafError(`${path} n'est pas un script shell : y ajouter à la main « raf hook post-commit »`);
+        throw new RafError(`${path} n'est pas un script shell : y ajouter à la main « raf hook ${name} »`);
     }
     let next;
     if (current === '') {
@@ -34,3 +46,86 @@ export function installHook(cwd) {
     chmodSync(path, 0o755);
     return { path, changed: true };
 }
+/**
+ * Message d'un `git commit` d'après ses arguments (-m, -am, --message, plusieurs -m, -F) ; null sans message
+ * en ligne de commande (éditeur, --amend, -C…) ou si ce n'est pas un commit.
+ */
+export function messageFromArgv(argv) {
+    const at = argv.indexOf('commit');
+    if (at < 0)
+        return null;
+    const parts = [];
+    let file = null;
+    for (let i = at + 1; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--')
+            break;
+        if (a.startsWith('--message='))
+            parts.push(a.slice('--message='.length));
+        else if (a === '--message')
+            parts.push(argv[++i] ?? '');
+        else if (a.startsWith('--file='))
+            file = a.slice('--file='.length);
+        else if (a === '--file')
+            file = argv[++i] ?? null;
+        else if (/^-[A-Za-z]+$/.test(a) && /[mF]$/.test(a)) {
+            // « -am », « -qm » : la dernière lettre prend l'argument suivant.
+            const value = argv[++i] ?? '';
+            if (a.endsWith('m'))
+                parts.push(value);
+            else
+                file = value;
+        }
+        else if (/^-[A-Za-z]*m./.test(a) && !a.startsWith('--'))
+            parts.push(a.slice(a.indexOf('m') + 1));
+        else if (/^-F./.test(a))
+            file = a.slice(2);
+    }
+    if (parts.length > 0)
+        return parts.join('\n\n');
+    if (file !== null) {
+        try {
+            return readFileSync(file === '-' ? 0 : file, 'utf8');
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/** Arguments du processus `pid` (Linux : /proc) ; null si illisibles. */
+function argvOf(pid) {
+    try {
+        return readFileSync(`/proc/${pid}/cmdline`, 'utf8').split('\0').slice(0, -1);
+    }
+    catch {
+        return null;
+    }
+}
+function parentOf(pid) {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+        const ppid = Number(stat.slice(stat.lastIndexOf(')') + 2).split(' ')[1]);
+        return Number.isInteger(ppid) && ppid > 1 ? ppid : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Message du commit en cours depuis un pre-commit, quand git ne le donne pas encore : celui de la ligne de
+ * commande du `git commit` qui nous a lancés (ancêtres du hook), ou CADENCE_COMMIT_MESSAGE. Null sinon.
+ */
+export function pendingCommitMessage(env, pid = process.ppid) {
+    if (env.CADENCE_COMMIT_MESSAGE)
+        return env.CADENCE_COMMIT_MESSAGE;
+    let cur = pid;
+    for (let depth = 0; cur !== null && depth < 6; depth++) {
+        const argv = argvOf(cur);
+        const msg = argv && /(^|\/)git$/.test(argv[0] ?? '') ? messageFromArgv(argv) : null;
+        if (msg !== null)
+            return msg;
+        cur = parentOf(cur);
+    }
+    return null;
+}

package/dist/lead.js

@@ -16,27 +16,42 @@ const empty = (project) => ({ project, doing: [], drift: [], notes: [], next: nu
 export function truncate(text, max) {
     return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
-/** Sous-dossiers directs qui portent un plan : docs/plan/raf.yaml, ou un cadence.yaml avec `plan:`. */
-export function findProjects(parent) {
-    return readdirSync(parent, { withFileTypes: true })
-        .filter((e) => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules')
-        .map((e) => join(parent, e.name))
-        .filter((dir) => {
-        if (existsSync(join(dir, 'docs/plan/raf.yaml')))
-            return true;
-        const conf = join(dir, 'cadence.yaml');
-        if (!existsSync(conf) || !statSync(conf).isFile())
-            return false;
-        try {
-            const c = readPlanConfig(conf);
-            // Une clé qa: seule ne désigne aucun plan.
-            return !!c && (!!c.path || Object.keys(c.settings).some((k) => k !== 'qaExpectations'));
-        }
-        catch {
-            return true; // un cadence.yaml illisible reste un projet : sa ligne dit l'erreur
-        }
-    })
-        .sort();
+/** Un dossier est un projet s'il porte docs/plan/raf.yaml, ou un cadence.yaml avec `plan:`. */
+function isProject(dir) {
+    if (existsSync(join(dir, 'docs/plan/raf.yaml')))
+        return true;
+    const conf = join(dir, 'cadence.yaml');
+    if (!existsSync(conf) || !statSync(conf).isFile())
+        return false;
+    try {
+        const c = readPlanConfig(conf);
+        // Une clé qa: seule ne désigne aucun plan.
+        return !!c && (!!c.path || Object.keys(c.settings).some((k) => k !== 'qaExpectations'));
+    }
+    catch {
+        return true; // un cadence.yaml illisible reste un projet : sa ligne dit l'erreur
+    }
+}
+/** Les projets sous `parent`, jusqu'à `depth` niveaux (1 : sous-dossiers directs) ; on ne descend pas dans un projet. */
+export function findProjects(parent, depth = 1) {
+    const found = [];
+    let entries;
+    try {
+        entries = readdirSync(parent, { withFileTypes: true });
+    }
+    catch {
+        return found; // dossier illisible : on le saute, les autres projets tournent
+    }
+    for (const e of entries) {
+        if (!e.isDirectory() || e.name.startsWith('.') || e.name === 'node_modules')
+            continue;
+        const dir = join(parent, e.name);
+        if (isProject(dir))
+            found.push(dir);
+        else if (depth > 1)
+            found.push(...findProjects(dir, depth - 1));
+    }
+    return found.sort();
 }
 /** Les faits de `cadence session start` pour un projet, sous forme de données ; lecture seule. */
 export function tourRow(dir, today, idle = TOUR_IDLE) {

package/package.json

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

@@ -8,12 +8,13 @@ description: Close a work session on a repository that uses cadence — plan hyg
 ## Where to run
 
 Every `cadence` / `raf` command works on the git repository of the current directory. When the
-session runs from a parent folder that holds several projects (not itself a repository), run each
-command inside the project concerned: `cd <project> && cadence …`. The projects are the sub-folders
-that contain `docs/plan/raf.yaml`, or a `cadence.yaml` with a `plan:` key.
+session runs from a parent folder that holds several projects (not itself a repository), run
+`cadence session close --all` there (`--depth 2` for projects one folder deeper): one "## project"
+section per sub-folder that contains `docs/plan/raf.yaml`, or a `cadence.yaml` with a `plan:` key.
+Other commands (`raf …`, `cadence deliver`) still run inside the project concerned: `cd <project> && cadence …`.
 
-With no project named, run `cadence session close` in each project touched during the session
-(`git log --since` or `git status` tell which) and close each one.
+With no project named, run `cadence session close --all` from the parent folder, or `cadence session close` in each project touched during the session
+(`git log --since` or `git status` tell which), and close each one.
 
 ## Steps
 

package/skills/session-start/SKILL.md

@@ -12,11 +12,12 @@ proposes, and stops.
 ## Where to run
 
 Every `cadence` / `raf` command works on the git repository of the current directory. When the
-session runs from a parent folder that holds several projects (not itself a repository), run each
-command inside the project concerned: `cd <project> && cadence …`. The projects are the sub-folders
-that contain `docs/plan/raf.yaml`, or a `cadence.yaml` with a `plan:` key.
+session runs from a parent folder that holds several projects (not itself a repository), run
+`cadence session start --all` there (`--depth 2` for projects one folder deeper): one "## project"
+section per sub-folder that contains `docs/plan/raf.yaml`, or a `cadence.yaml` with a `plan:` key.
+Other commands (`raf …`, `cadence deliver`) still run inside the project concerned: `cd <project> && cadence …`.
 
-With no project named, run `cadence session start` in **each** project that has a plan and report
+With no project named, run `cadence session start --all` from the parent folder (or `cadence session start` in **each** project that has a plan) and report
 one or two lines per project (in progress, drift, notes left at the last close), then propose the
 three most useful items across projects and wait. With a project named, work in that one only.