@sylad/cadence 0.14.0 → 0.16.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.16.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.16.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.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),
@@ -91,15 +91,38 @@ raf gantt                         # docs/plan/gantt.html
 | `raf public <id> "title"` · `raf public <id> --clear` | set, replace or remove the public title of a lot |
 | `raf start <id>` · `raf done <id> [--force]` · `raf drop <id> [--reason text]` | dated transitions (`done` refuses open sub-tasks unless `--force`) |
 | `raf note <id> "text"` | dated note — keep decisions next to the work |
-| `raf show <id> [--notes]` | one lot: status, dates, `after`, public title, dated notes in order, then the counted commits (as `raf commits`); `--notes` prints the notes alone |
-| `raf commits <id>` | the commits counted for a lot (the set the code review gate uses), one `<sha> <subject>` per line, oldest first |
+| `raf show <id> [--notes]` | one lot: status, dates, `after`, public title, dated notes in order, then the counted commits (as `raf commits`, neighbouring repositories included); `--notes` prints the notes alone |
+| `raf commits <id>` | the commits counted for a lot (the set the code review gate uses), one `<sha> <subject>` per line, oldest first; a lot that declares `repos:` ([neighbouring repositories](#a-lot-whose-work-is-in-a-neighbouring-repository)) gets, after them, one `dépôt <path> :` section per neighbour with the commits there that cite the lot and fall within the lot's period (`started` to `finished`) and, when the lot declares a `cite:` for that neighbour, contain that string (`aucun commit du lot`, or `introuvable` for a path that is not there) |
 | `raf now` | what to do next |
 | `raf list [--status s]` | flat list |
 | `raf ignore <sha> \| "exact subject" [--reason text]` | acknowledge a commit without a lot (tooling chore, a plan commit citing an unknown id) without rewriting history: a dated, reasoned line in the plan's `acknowledged:` section; a sha is exact, a subject covers every commit carrying it |
 | `raf check --ignored` | list the acknowledged commits with their date and reason |
 | `raf check [--since date] [--idle 7]` | since the plan's adoption date by default (a visible lot without a public title is only a `⚠` warning: it never changes the exit code): commits without a lot (commits touching only plan files are exempt), unknown ids, `todo` lots that already have commits, idle lots, `done` lots with open sub-tasks, bad or circular dependencies |
 | `raf 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 …`.
@@ -172,6 +195,7 @@ plan:
     started: demarre_le
     finished: [livre_le, ferme_le]
     notes: note
+    repos: depots               # the lot's neighbouring repositories (a list of paths and/or { path, cite }, or one of them)
     parent: parent
   statuses:                     # raf status: their states
     todo: [prevu, specifie]
@@ -182,7 +206,7 @@ plan:
 ```
 
 - Fields: `id`, `title`, `status`, `estimate`, `quickwin`, `visible`, `public`, `every`, `last`, `after`, `created`, `started`,
-  `finished`, `notes`, `parent`; one left out is read under its own name. A timestamp counts for
+  `finished`, `notes`, `repos`, `parent`; one left out is read under its own name. A timestamp counts for
   its day; a note written as plain text is one note.
 - `parent`: an entry `B33/t1-fusion` whose parent is `B33` becomes the sub-task `t1-fusion` of `B33`.
 - Ids need no prefix: a commit belongs to a lot when its message cites one of the plan's ids as a
@@ -311,6 +335,12 @@ written by hand without a `commit` field is not checked for staleness. An empty
 verdict is refused, and one left empty or blank by hand in the YAML counts as no
 review. Plans without `reviewSince` are not affected.
 
+A lot that works in neighbouring repositories (`repos:`, see [orchestrate](#a-lot-whose-work-is-in-a-neighbouring-repository))
+has its verdict tied to each of them: `raf review` also stores, under `repos`, the sha of the latest counted commit of the
+lot in each neighbour (the one `raf commits` lists last: it cites the lot, falls within the lot's period and contains the `cite:` string if any) (`review: { date, verdict, commit, repos: { ../aetherwx-gitops: <sha> } }`, `null` when a
+neighbour has none), and refuses to record when a listed repository cannot be read. `raf check` does not audit the
+neighbours: their staleness is not checked, only the project's own commits are.
+
 ### QA review
 
 No gate and no command here: the QA review comes **after** a delivery, and
@@ -387,10 +417,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`.
 
@@ -784,6 +825,60 @@ The sessions of the wave also get `.cadence/runs/<wave>/tool/bin` (the `raf` and
 `PATH`**, ahead of the per-project Node below and of the usual `PATH`: the `raf` a reviewer runs (`raf commits`…) is the
 snapshot's, not the installed one. A wave without a snapshot leaves the `PATH` as it is.
 
+### A lot whose work is in a neighbouring repository
+
+Some lots are done in another repository that is not a cadence project (B64 of `maritime-atlas` lives in
+`aetherwx-gitops`, a Helm chart repository). The lot declares it with the **lot key `repos:`** — a list of paths relative to
+the project's repository, one path being enough as a string. There is no project-wide key: a neighbour belongs to a lot.
+
+```yaml
+lots:
+  - id: B64
+    title: …
+    repos: [../aetherwx-gitops]
+```
+
+**Which commits count in a neighbour.** Nothing is inferred from the neighbour or from the project's name. A commit counts
+when it cites the lot's id (as in the project: `feat(B64): …`, `maritime: … (B64)`) **and** is dated within the lot's period,
+`started` to `finished` (an open end is open). That is all, whatever the prefix or scope of the subject says and whatever
+the commit mentions. When a neighbour is shared between projects whose lots share an id prefix (`developpeur-gitops` holds
+the charts of `finance-tracker`, `warhammer40k` and `ol-companion`, all `L…`), the lot says so with an **explicit key**: an
+entry of `repos:` can be an object, and the list can mix both forms.
+
+```yaml
+    repos:
+      - ../aetherwx-gitops                                  # id + period
+      - { path: ../developpeur-gitops, cite: ol-companion } # id + period + this string
+```
+
+With `cite`, a commit must also contain that string (a substring, case-insensitive, searched in the subject and the body);
+a commit of another app that cites the same id is dropped from `raf commits`, from the briefs, from the sha a review
+records and from the orchestrator's « already has work » test. Without `cite`, in a shared neighbour, the commits of the
+other apps that cite the same id **do** count: that is the default, so declare `cite` for such a neighbour. `cite` applies
+to the neighbour it is written on, not to the project's own repository. The commits of the lot in the neighbour must carry the
+string too (the briefs say so); one that does not is not counted.
+
+A read-only plan declares it in `cadence.yaml` with `plan.fields.repos: <the file's key>` (a left-out field is read under
+the name `repos`). The effect, for `cadence orchestrate`:
+
+- **Preconditions** (refused before acting, exit code 2, like the project's own repository): every listed path exists and
+  is inside a git repository, has no tracked file modified, has no `pre-push` hook of its own, and is not held by another
+  live orchestration. `--dry-run` applies the same refusals and prints `dépôts voisins : <paths>`. The project's own
+  repository and a duplicate listed twice are counted once.
+- **Lock and guard**: the neighbour gets the repository lock (`orchestrate.lock`, so `cadence deliver` refuses it too, and no
+  other wave can hold it), the temporary `pre-push` hook, and the same after-session checks (push, tampered hook, a review
+  that changed it). Two lots that share a repository, as project or as neighbour, run one after the other, never two
+  sessions in one repository; `--status` lists the neighbours among the repositories a wave holds.
+- **Sessions**: every session gets each neighbour as `--add-dir`, and the briefs name them: the implementation and the
+  corrections must commit there too, with a message that cites the lot (`feat(B64): …`), and never push; the reviewers read
+  the commits that cite the lot in the project **and** in each neighbour (`raf commits <lot>` lists them all; in a neighbour only the commits that cite the lot and are dated within the lot's period count, and also contain the `cite:` string when the lot declares one for it — a `fix(B64): …` outside the period, or one without the `cite:` string, is not listed.) A lot whose
+  whole work is in the neighbour is not « without commit »; a commit there that does not cite the lot is a warning; a
+  neighbour left with a tracked file modified hands the lot back.
+- **Verdict**: `raf review` as recorded by the orchestrator stores the sha read in the project and in each neighbour
+  (`review.repos`), and the verdict text ends with `dépôts relus : <path>@<sha>`. A commit made in a neighbour after the
+  review hands the lot back, like one in the project.
+- **Out of scope**: `raf check` does not audit the neighbours, and their delivery (push, CI, deploy) stays with the lead.
+
 **What stays with you**: choosing the lots, the questions raised (`--resume --answer`), re-verifying
 after the wave (`git log`, tests, `raf check`), `raf done`, **`raf ux`** (the orchestrator reports the UX
 verdict and screenshots, it does not record it), the push and the deliveries, one project at a time.

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,23 @@
-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 { repoSections, repoShas, resolveLotRepos } from './repos.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 +41,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 +115,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 +134,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 +160,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.
@@ -283,6 +291,8 @@ function dispatch(argv, io) {
             // Une lecture : le même ensemble que « raf done » et « raf check », plan en lecture seule compris.
             for (const c of lotWork(plan, root, id).reverse())
                 io.out(short(c));
+            for (const line of repoSections(plan, root, plan.lot(id)))
+                io.out(line);
             return 0;
         }
         case 'show': {
@@ -313,6 +323,8 @@ function dispatch(argv, io) {
             io.out(`commits (${commits.length}) :`);
             for (const c of commits)
                 io.out(`  ${short(c)}`);
+            for (const line of repoSections(plan, root, lot, '  '))
+                io.out(line);
             return 0;
         }
         case 'list': {
@@ -383,8 +395,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))
@@ -476,8 +490,13 @@ function gate(kind, rest, loadPlan, root, today, io) {
     if (kind === 'ux')
         plan.recordUx(rest[0], verdict, today);
     // Le verdict vaut jusqu'au dernier commit compté du lot ; un plan en lecture seule refuse sans lire git.
-    else
-        plan.recordReview(rest[0], verdict, today, plan.readonly ? null : (lotWork(plan, root, rest[0])[0]?.sha ?? null));
+    else {
+        // Les dépôts voisins du lot : un dépôt qu'on ne peut pas lire ferait enregistrer un verdict sur un sha non lu.
+        const neighbours = plan.readonly || rest[0].includes('/') ? undefined : resolveLotRepos(root, plan.lots().find((l) => l.id === rest[0]) ?? {});
+        if (neighbours?.problems.length)
+            throw new RafError(`${neighbours.problems.join(' ; ')} — la revue de code relit aussi les dépôts du lot`);
+        plan.recordReview(rest[0], verdict, today, plan.readonly ? null : (lotWork(plan, root, rest[0])[0]?.sha ?? null), neighbours?.repos.length ? repoShas(plan, neighbours.repos, rest[0]) : undefined);
+    }
     plan.save();
     return 0;
 }
@@ -535,11 +554,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 +720,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 +794,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;
+}