@sylad/cadence 0.13.1 → 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.13.1",
+      "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.13.1",
+  "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.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`.
 
@@ -455,6 +489,32 @@ The commands get `CADENCE_SINCE` (the `--since` in effect) and `CADENCE_TODAY`.
 add facts and decide nothing: a failing command is reported and changes neither
 the exit code nor the verdict.
 
+## lead tour
+
+`cadence lead tour [folder] [--idle 3] [--json]` is the lead's morning table, with no model in
+the loop. From a parent folder (default: the current one) it takes every direct sub-folder that
+holds `docs/plan/raf.yaml`, or a `cadence.yaml` with a `plan:` key (a plan kept by another tool
+included), and for each one reads the same facts as `cadence session start` — in-process, no
+sub-process, no call to `claude` — then prints **one line per project**:
+
+```
+alpha · en cours L1 (silencieux 4j) · dérive 1 (✗ L2 a 1 commit(s) mais est encore todo) · notes : finir L1 puis livrer · prochain L3 Typo · dépôt non commité, non poussé
+beta · en cours rien · dérive aucune · notes : aucune · prochain T2 Second · dépôt propre
+```
+
+| Column | Content |
+|---|---|
+| `en cours` | ids of the lots in progress; `(aucune activité)` when it has none at all, `(silencieux Nj)` when the lot's last activity (commit, note or start) is more than `--idle` days old (default 3) |
+| `dérive` | the gaps `raf check` reports, counted and the first two shown |
+| `notes` | the notes left by the last `session close`, joined with ` / ` and cut at 120 characters |
+| `prochain` | the first ready lot (quick wins first) — id and title cut at 60 characters |
+| `dépôt` | `non commité` (modified or untracked files), `non poussé` (commits ahead of the upstream), `livraison en cours` (live delivery lock); `propre` otherwise |
+
+`--json` prints the same content as an array of objects (`project`, `doing`, `drift`, `notes`,
+`next`, `repo`, and `error` when the project could not be read). The tour is read-only: it changes
+no plan. It exits 0 even when a project is in error — that project's line reads
+`beta · ✗ erreur : <cause>`. The `lead` skill runs it instead of one subagent per project.
+
 ## deliver
 
 A delivery is done when its checks pass, not when a tool says "success".
@@ -937,8 +997,8 @@ repository with `cadence skills install` (to `.claude/skills/cadence-*` and
 - **deliver**: dry run, delivery, and on failure the cause fixed rather than a
   blind retry; after a green delivery that changes what a page shows or what it
   is served, the `qa-reviewer` agent walks the delivered app.
-- **lead**: from a folder holding several projects, one subagent per project
-  gathers the facts, you choose the priorities, the lots are delegated with
+- **lead**: from a folder holding several projects, `cadence lead tour` (a program,
+  no model: see [lead tour](#lead-tour)) prints one line of facts per project, you choose the priorities, the lots are delegated with
   `cadence orchestrate` (fresh short sessions with a standard brief — test first,
   README and usage documentation updated with the change, commits citing the lot, no push — reviewed by the `code-reviewer` agent, see
   [orchestrate](#orchestrate)), re-verified by the lead, then delivered

package/bin/cadence.js

@@ -13,7 +13,7 @@ const io = {
 
 if (tool === 'raf') {
   process.exitCode = await run(args, io);
-} else if (['news', 'session', 'deliver', 'verify', 'skills', 'orchestrate'].includes(tool)) {
+} else if (['news', 'session', 'deliver', 'verify', 'skills', 'orchestrate', 'lead'].includes(tool)) {
   process.exitCode = await run([tool, ...args], io);
 } else if (tool === '--version' || tool === '-v') {
   const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
@@ -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]
@@ -37,6 +38,8 @@ if (tool === 'raf') {
   cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--max-sessions 2] [--wave id] [--dry-run]
                     une session claude neuve par étape (implémentation, revues, corrections) ; --status, --resume ;
                     --max-sessions : sessions simultanées, toutes vagues confondues (CADENCE_MAX_SESSIONS)
+  cadence lead tour [dossier] [--idle 3] [--json]
+                    le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan
   cadence skills install [--dir .claude] [--force]
                     installe les skills Claude Code session-start, session-close, deliver et l'agent ux-reviewer`);
   process.exitCode = !tool || ['help', '--help', '-h'].includes(tool) ? 0 : 2;

package/dist/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,21 +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 { 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';
@@ -39,8 +40,9 @@ 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
   raf news new <lot…> [--title t] | list | check | stamp | build [-o dossier]   (aussi « cadence news … »)
 
@@ -112,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' },
@@ -120,6 +124,7 @@ function dispatch(argv, io) {
             clear: { type: 'boolean' },
             ignored: { type: 'boolean' },
             notes: { type: 'boolean' },
+            json: { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
         },
     });
@@ -128,10 +133,35 @@ 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)`);
     const root = gitRoot(io.cwd) ?? io.cwd;
+    // Le tour parcourt les sous-dossiers : il ne lit ni le plan ni le cadence.yaml du dossier courant.
+    if (command === 'lead') {
+        if (rest[0] !== 'tour' || rest.length > 2)
+            throw new RafError('usage : cadence lead tour [dossier] [--idle 3] [--json]');
+        const idle = values.idle === undefined ? undefined : Number(values.idle);
+        if (idle !== undefined && !(Number.isInteger(idle) && idle >= 0))
+            throw new RafError(`--idle invalide : ${values.idle}`);
+        const parent = resolve(io.cwd, rest[1] ?? '.');
+        if (!existsSync(parent))
+            throw new RafError(`lead tour : dossier introuvable : ${parent}`);
+        const rows = leadTour(parent, today, idle);
+        if (values.json)
+            io.out(JSON.stringify(rows, null, 2));
+        else if (rows.length === 0)
+            io.out(`aucun projet sous ${parent} (docs/plan/raf.yaml ou cadence.yaml avec plan:)`);
+        else
+            for (const r of rows)
+                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.
@@ -360,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))
@@ -512,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;
@@ -623,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': {
@@ -653,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

@@ -0,0 +1,106 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { audit, nextUp, planCommits } from './audit.js';
+import { readPlanConfig } from './config.js';
+import { diffDays } from './dates.js';
+import { gitRoot, repoStatus } from './git.js';
+import { linkCommits } from './link.js';
+import { Plan } from './plan.js';
+import { lastActivity, lockStatus } from './session.js';
+import { readNext, sharedStateDir, stateDir } from './state.js';
+export const NOTES_MAX = 120;
+export const TITLE_MAX = 60;
+/** Au-delà de ce nombre de jours sans activité, un lot en cours est dit silencieux. */
+export const TOUR_IDLE = 3;
+const empty = (project) => ({ project, doing: [], drift: [], notes: [], next: null, repo: [] });
+export function truncate(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+/** Un dossier est un projet s'il porte docs/plan/raf.yaml, ou un cadence.yaml avec `plan:`. */
+function isProject(dir) {
+    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) {
+    const row = empty(basename(dir));
+    try {
+        const root = gitRoot(dir) ?? dir;
+        const configPath = join(root, 'cadence.yaml');
+        const planConfig = readPlanConfig(configPath, root);
+        const planPath = resolve(root, planConfig?.path ?? 'docs/plan/raf.yaml');
+        const plan = Plan.load(planPath, { ...planConfig?.settings, config: configPath });
+        const lots = plan.lots();
+        const all = linkCommits(lots, planCommits(plan, root), plan.refs);
+        const { doing, ready } = nextUp(lots);
+        row.doing = doing.map((l) => {
+            const last = lastActivity(l, all.byLot.get(l.id) ?? []);
+            if (!last)
+                return { id: l.id, noActivity: true };
+            const days = diffDays(last, today);
+            return days > idle ? { id: l.id, silentDays: days } : { id: l.id };
+        });
+        row.drift = audit(plan, root, join(root, 'docs/nouveautes'), today).map((i) => `${i.warning ? '⚠' : '✗'} ${i.message}`);
+        row.notes = readNext(stateDir(root))?.lines ?? [];
+        row.next = ready[0] ? { id: ready[0].id, title: ready[0].title } : null;
+        const s = repoStatus(root);
+        if (s.dirty || s.untracked)
+            row.repo.push('non commité');
+        if (s.ahead)
+            row.repo.push('non poussé');
+        if (lockStatus(sharedStateDir(root))?.live)
+            row.repo.push('livraison en cours');
+    }
+    catch (e) {
+        return { ...empty(row.project), error: (e instanceof Error ? e.message : String(e)).split('\n')[0] };
+    }
+    return row;
+}
+export function leadTour(parent, today, idle = TOUR_IDLE) {
+    return findProjects(parent).map((dir) => tourRow(dir, today, idle));
+}
+const DRIFT_SHOWN = 2;
+/** Une ligne par projet : projet · en cours · dérive · notes · prochain lot prêt · dépôt. */
+export function tourLine(r) {
+    if (r.error)
+        return `${r.project} · ✗ erreur : ${r.error}`;
+    const doing = r.doing.length ? r.doing.map((d) => (d.noActivity ? `${d.id} (aucune activité)` : d.silentDays === undefined ? d.id : `${d.id} (silencieux ${d.silentDays}j)`)).join(', ') : 'rien';
+    const drift = r.drift.length
+        ? `${r.drift.length} (${r.drift.slice(0, DRIFT_SHOWN).join(' ; ')}${r.drift.length > DRIFT_SHOWN ? ' ; …' : ''})`
+        : 'aucune';
+    const notes = r.notes.length ? truncate(r.notes.join(' / '), NOTES_MAX) : 'aucune';
+    const next = r.next ? `${r.next.id} ${truncate(r.next.title, TITLE_MAX)}` : 'aucun';
+    return [r.project, `en cours ${doing}`, `dérive ${drift}`, `notes : ${notes}`, `prochain ${next}`, `dépôt ${r.repo.length ? r.repo.join(', ') : 'propre'}`].join(' · ');
+}

package/dist/session.js

@@ -46,7 +46,7 @@ function byLotLines(linked) {
     });
 }
 /** Ligne de livraison en cours ; `live` faux quand le verrou appartient à un processus mort. */
-function lockStatus(state) {
+export function lockStatus(state) {
     const lock = readLock(state);
     if (!lock)
         return null;
@@ -77,7 +77,7 @@ function section(out, title, lines) {
         out(`  ${l}`);
 }
 /** Dernière activité d'un lot : dernier commit, dernière note ou démarrage. */
-function lastActivity(lot, commits) {
+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;
 }

package/package.json

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

@@ -1,12 +1,12 @@
 ---
 name: lead
-description: Lead several cadence projects from a parent folder without loading them into the main context — fan out one subagent per project to gather the facts, agree the priorities with the human, delegate each chosen lot to a subagent with a standard brief, have the work reviewed, re-verify it yourself, then deliver one project at a time. Triggers — "/lead", "pilot all projects", "on pilote tout", "délègue aux sous-agents", start of a multi-project day.
+description: Lead several cadence projects from a parent folder without loading them into the main context — take the facts of every project with `cadence lead tour`, agree the priorities with the human, delegate each chosen lot to a subagent with a standard brief, have the work reviewed, re-verify it yourself, then deliver one project at a time. Triggers — "/lead", "pilot all projects", "on pilote tout", "délègue aux sous-agents", start of a multi-project day.
 ---
 
 # Lead — decide at the top, work in subagents
 
 The lead session stays small: it reads summaries, decides with the human, delegates, checks and
-delivers. Project files are read and changed by subagents, each with its own context. The projects
+delivers. Project files are changed by subagents, each with its own context; the facts of the tour come from `cadence lead tour`, a program. The projects
 are the sub-folders of the current directory that contain `docs/plan/raf.yaml`, or a `cadence.yaml`
 with a `plan:` key. A project whose `cadence.yaml` maps the fields of a plan kept by its own tool is
 **read-only** for `raf`: it takes part in the tour, and its plan is changed with the project's own
@@ -30,9 +30,12 @@ commands (its CLAUDE.md names them), never with `raf start|done|note|ux|review`.
 
 ## 1. Tour of the projects
 
-For each project, a subagent (read-only) runs `cd <project> && cadence session start` and returns at
-most five lines: lots in progress (silent ones flagged), drift, notes from the last close, the next
-ready lot. Two at a time, in the background.
+Run `cadence lead tour` from the parent folder (one command, no subagent, no model: it reads the same
+facts as `cadence session start` for every project). It prints one line per project — lots in progress
+(`silencieux Nj` when idle for more than three days), drift, notes from the last close, the next ready lot,
+repository state — and exits 0 even when a project is in error (its line says so). `--json` gives the same
+content. Read the lines yourself; open a project's own `cadence session start` only for the one you need to
+look at closer.
 
 Then report to the human in a compact table — one row per project — and propose **three** items
 across projects, each with project, lot id and one sentence of justification: finish what is in

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.