@sylad/cadence 0.7.0 → 0.8.0

package/.claude-plugin/marketplace.json

@@ -6,7 +6,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.7.0",
+      "version": "0.8.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.7.0",
+  "version": "0.8.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/README.md

@@ -27,13 +27,19 @@ reports a page left empty or in error.
   `fix: L3/t1 …`. The link is **computed from `git log`**, never stored, so
   committing never dirties the plan. The id is read as a whole word: `XL3`,
   `L3x` and `L3.4` do not cite `L3`, while `L3.` at the end of a sentence does.
+  When the subject has a scope that cites lots (`feat(L3): …`,
+  `chore(L31,L32): …`), **the scope alone decides**: a passing mention
+  (`page équipe (L27)`), a range (`L28–L31`, `L45 à L48`) or the body does not
+  count. Without a scope citing a lot, the whole message is read as before.
 - `raf check` audits drift between the plan and the history.
 - Plan upkeep needs no lot. A commit is plan upkeep when **every file it
-  touches is a plan file**: the plan itself, its Gantt page, or a file the
+  touches is a plan file**: the plan itself, its Gantt page (only at its default place, `gantt.html` next to the plan — written elsewhere with `raf gantt -o`, declare it under `plan.files`), the `plan:` key of the config file in use (`cadence.yaml`, or
+  the `--config` file; a change to `deliver:`/`session:` is work), or a file the
   project lists under `plan.files` in `cadence.yaml` (a page it generates from
   the plan, a journal). Such a commit is never a "commit without a lot", and it
   does not count as work on the lots it cites: it is absent from `raf commits`,
-  does not start a `todo` lot and does not make a code review stale. The files
+  does not start a `todo` lot, does not make a code review stale, and
+  `cadence deliver` does not announce the lots it cites as delivered. The files
   decide, never the subject: a `chore(plan): …` commit that touches a source
   file is a commit like any other.
 - `raf gantt` writes a single self-contained HTML page (no server, no CDN).
@@ -411,7 +417,35 @@ cadence deliver              # 0 delivered and verified · 1 a step failed · 2
   process died is removed with a warning); with `ci: github`, `gh` installed and
   logged in.
 - Every command is killed when it exceeds its budget (CI, `deployTimeout`, what is
-  left of `verifyTimeout`) and reported as "délai dépassé".
+  left of `verifyTimeout`) and reported as "délai dépassé". Killed means the
+  whole tree, followed while the command runs: every 200 ms cadence lists the
+  command's descendants and remembers each process it has seen with its start
+  time, so a process whose parent exits (re-parented to init — a background
+  child of a script, `sh`'s fork for each command) stays known. To kill, cadence
+  takes every remembered process still alive with the same start time (never a
+  recycled pid) plus all its current descendants, stops each one first
+  (`SIGSTOP`, the tree is re-read until nothing new appears), then kills them
+  (`SIGKILL`). This happens on a delay overrun, and at once when cadence
+  receives `SIGTERM`. On Ctrl-C or a hangup the tree has already received the
+  signal from the terminal: cadence gives the whole followed set, not just the
+  command, up to 2 seconds to finish (a script's `trap`, git removing its
+  `index.lock`), carries on the moment none of it is alive, and kills what is
+  left after the 2 seconds, a background child that ignores Ctrl-C included.
+  A delay overrun and `SIGTERM` give no grace: a script's own `trap` does not
+  get to finish there. The lock is held until the followed set is empty: when
+  cadence dies of the signal it dies after the tree, and its stale lock, which
+  the next delivery removes, leaves nothing of the first delivery running.
+  What can still outlive cadence and run concurrently with the next delivery:
+  a process that leaves the tree before cadence first sees it (a daemon's
+  double fork, `setsid`, `nohup … &` from a shell that exits, all within less
+  than 200 ms), a process of another user that cadence may not signal (`sudo`),
+  a background process still running when the command returns normally (it is
+  neither waited for nor killed), and everything if cadence itself is killed
+  with `SIGKILL` (`kill -9`, the OOM killer).
+- Commands run in cadence's own process group and session, attached to the
+  terminal: `ssh`, `sudo` or `pinentry` can prompt on `/dev/tty`, and Ctrl-C or
+  closing the terminal stops the running command together with cadence (within
+  the limits above).
 - **CI** `github`: polls `gh run list --commit <sha>` every 15 s; no run after
   5 minutes is a failure (you probably pushed another commit than the one you
   deliver); every run must end `success`, `skipped` or `neutral`. `gh` errors
@@ -422,7 +456,9 @@ cadence deliver              # 0 delivered and verified · 1 a step failed · 2
   listed, so you can `raf done` those whose effect you have seen. With a
   read-only plan, only the lots that were in progress when the delivery started
   are listed: an id quoted in a message for context (a finished lot, a
-  reservation number that looks like one) is not a delivered lot.
+  reservation number that looks like one) is not a delivered lot. Plan upkeep
+  commits (see "Plan upkeep needs no lot") are skipped in that list: they cite
+  lots without delivering anything.
 
 ### A project with its own delivery script
 
@@ -455,6 +491,60 @@ intact. If the script commits and pushes during the delivery (stamping a
 changelog entry, say), the new `HEAD` is the sha recorded as delivered. Exit code
 0 of the script means delivered; `verify` checks, if any, run after it.
 
+### verify: replay the effect checks, outside a delivery
+
+A green delivery says the effect was right *then*. `cadence verify` replays the
+`deliver.verify` checks of `cadence.yaml` at any time — no CI, no deploy, no lock,
+no journal entry, nothing written.
+
+```sh
+cadence verify                # one pass, one line per check, then a one-line summary
+cadence verify --retry 60     # retry each failing check for up to 60 s (deliver's 300 s is not applied)
+cadence verify --sha 6b0d9aa  # the sha that replaces ${SHA} / ${SHORT} (default: last delivery, else HEAD)
+```
+
+```
+✓ GET https://ol.example/api/health → 200
+✗ GET https://ol.example/api/lineup → 200, contient « "starters" » — « "starters" » absent de la réponse
+verify : 1 effet rouge sur 2 vérifications
+```
+
+Exit code: **0** every check green · **1** at least one red effect · **2** nothing
+to verify or invalid configuration.
+
+Time limits differ from deliver's. `verify` runs all the checks **in parallel**,
+each try with the whole 120 s limit (a `url` request gives up after 20 s; a slow
+check is killed at its limit, "délai dépassé", and takes nothing from the others); results are printed in the order
+of `cadence.yaml`. Retries repeat every 10 s (deliver's interval) up to `--retry`
+seconds for each check on its own, so a run lasts at most `--retry` + 120 s.
+deliver, by contrast, runs its checks one after the other, retries each until
+`verifyTimeout` (300 s by default) is spent, and stops at the first check that
+never turns green. The check code is deliver's own (`url` / `status` /
+`contains` / `command`, same messages). A project with
+a delivery script (`deliver.script`) and no `verify` declares no effect checks —
+`verify` says so and exits 2 (its script's own checks stay its business); add
+`deliver.verify` to replay some.
+
+Each `command` check of `verify` (and of `session start`) runs in a process group
+of its own, detached from the terminal (no `/dev/tty`: a check must not prompt).
+At its time limit the whole group is killed, so no child survives it; Ctrl-C,
+`SIGTERM` or a closed terminal is passed on to the running checks before cadence
+exits. As the checks run together, the output of their commands may interleave;
+the result lines come after it, in order.
+
+Make `verify` count: a health endpoint stays green while the data is wrong (a
+lineup served empty for 38 h behind a green `/api/health`). Add a check on the
+content that matters, e.g. `url: …/api/lineup` with `contains: '"starters"'`.
+
+`cadence session start` runs the same checks in parallel (one try each, command
+output muted), each with a 10 s limit, so the whole step takes about 10 s at worst;
+it is not deliver's `verifyTimeout`, and there is no retry. It adds an
+**"Effets en production"** section to the morning report: a single `✓` line when
+everything is green, the red effects and the summary otherwise. It is a fact like
+the others: it never changes the exit code, and an unreachable network shows up
+as red lines ("erreur réseau") without blocking the session. No section for a
+project without `deliver.verify`.
+
 ## Claude Code skills
 
 As a plugin:

package/bin/cadence.js

@@ -13,7 +13,7 @@ const io = {
 
 if (tool === 'raf') {
   process.exitCode = await run(args, io);
-} else if (['news', 'session', 'deliver', 'skills'].includes(tool)) {
+} else if (['news', 'session', 'deliver', 'verify', 'skills'].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'));
@@ -31,6 +31,9 @@ if (tool === 'raf') {
   cadence deliver [--dry-run] [--sha rév] [--config cadence.yaml] [-- arguments du script du projet]
                     CI du sha poussé → déploiement → vérifications de l'effet ;
                     ou le script de livraison du projet (deliver.script), sous verrou et journal
+  cadence verify [--retry secondes] [--sha rév]
+                    rejoue les vérifications d'effet (deliver.verify) hors livraison, une passe, en parallèle ;
+                    code 0 tout vert, 1 un effet rouge, 2 rien à vérifier ; « session start » la lance aussi
   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

@@ -1,12 +1,34 @@
 import { dirname, join, relative } from 'node:path';
 import { check } from './check.js';
-import { changedFiles, readCommits } from './git.js';
+import { parse } from 'yaml';
+import { changedFiles, fileAt, readCommits } from './git.js';
 import { linkCommits } from './link.js';
 import { loadEntries, newsIssues } from './news.js';
 import { isOpen } from './plan.js';
-/** Le plan, sa page Gantt et les fichiers tenus avec lui (cadence.yaml : plan.files). */
+/** Chemin de la configuration lue, relatif à la racine : celui de --config, sinon cadence.yaml. */
+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) {
-    return new Set([relative(root, plan.path), relative(root, join(dirname(plan.path), 'gantt.html')), ...plan.files]);
+    return new Set([relative(root, plan.path), relative(root, join(dirname(plan.path), 'gantt.html')), configRel(plan, root), ...plan.files]);
+}
+function withoutPlanKey(text) {
+    if (text === null)
+        return '{}';
+    try {
+        const { plan: _plan, ...rest } = (parse(text) ?? {});
+        return JSON.stringify(rest, (_k, v) => (v && typeof v === 'object' && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort(([x], [y]) => x.localeCompare(y))) : v));
+    }
+    catch {
+        return null;
+    }
+}
+/** Le commit ne change de la configuration que la clé `plan:` ? Un fichier illisible avant ou après compte comme du travail. */
+function onlyPlanKeyChanged(root, sha, file) {
+    const before = withoutPlanKey(fileAt(root, `${sha}^`, file));
+    const after = withoutPlanKey(fileAt(root, sha, file));
+    return before !== null && before === after;
 }
 /** Commits du dépôt sans les commits automatiques (motifs `ignore`) : ni audités ni comptés pour un lot. */
 export function planCommits(plan, root, opts = {}) {
@@ -14,28 +36,25 @@ export function planCommits(plan, root, opts = {}) {
     const commits = readCommits(root, opts);
     return patterns.length ? commits.filter((c) => !patterns.some((re) => re.test(c.subject))) : commits;
 }
-/** Commit d'entretien du plan : ne touche-t-il que des fichiers du plan (plan, page Gantt, plan.files) ? */
+/**
+ * Commit d'entretien du plan : TOUS ses fichiers sont des fichiers du plan (le plan, sa page Gantt,
+ * plan.files — son plan publié par exemple — et la configuration lue, mais celle-ci seulement quand la
+ * clé `plan:` est la seule à changer : deliver/session/… sont du travail). Les fichiers décident,
+ * jamais le sujet : « chore(plan): … » qui touche un fichier source est un commit comme un autre.
+ */
 export function isPlanOnly(sha, plan, root) {
     const own = ownFiles(plan, root);
+    const config = configRel(plan, root);
     const files = changedFiles(root, sha);
-    return files.length > 0 && files.every((f) => own.has(f));
+    return files.length > 0 && files.every((f) => own.has(f) && (f !== config || onlyPlanKeyChanged(root, sha, f)));
 }
 /**
- * N'ont pas besoin de citer un lot : un commit d'entretien du plan — TOUS ses fichiers sont des fichiers
- * du plan (le plan, sa page Gantt, ceux que le projet déclare sous plan.files, son plan publié par
- * exemple) — et un commit automatique dont le sujet correspond à un motif `ignore:` du plan.
- * Les fichiers décident, jamais le sujet : « chore(plan): … » qui touche un fichier source est un
- * commit comme un autre.
+ * N'ont pas besoin de citer un lot : un commit d'entretien du plan (cf. isPlanOnly) et un commit
+ * automatique dont le sujet correspond à un motif `ignore:` du plan.
  */
 export function exemptPlanOnly(linked, plan, root) {
-    const own = ownFiles(plan, root);
     const { patterns } = plan.ignore;
-    const orphans = linked.orphans.filter((c) => {
-        if (patterns.some((re) => re.test(c.subject)))
-            return false;
-        const files = changedFiles(root, c.sha);
-        return files.length === 0 || !files.every((f) => own.has(f));
-    });
+    const orphans = linked.orphans.filter((c) => !patterns.some((re) => re.test(c.subject)) && !isPlanOnly(c.sha, plan, root));
     return { ...linked, orphans };
 }
 /** Fenêtre de l'audit : --since, sinon la date d'adoption du plan, sinon 30 jours. */

package/dist/cli.js

@@ -6,16 +6,17 @@ import { audit, exemptPlanOnly, isPlanOnly, lotWork, nextUp, planCommits, unrevi
 import { short } from './check.js';
 import { isDay, toDay } from './dates.js';
 import { deliver, parseDeliverConfig, realDeps } from './deliver.js';
+import { effectLines, realCheckDeps, verifyCommand } from './verify.js';
 import { ganttData, renderGantt } from './gantt.js';
-import { gitRoot, readCommits } from './git.js';
+import { gitRoot, headSha, readCommits, resolveCommit } from './git.js';
 import { installHook } from './hook.js';
-import { linkCommits } from './link.js';
+import { citedRefs, linkCommits } from './link.js';
 import { buildNews, loadEntries, newEntry, newsData, newsIssues, stampEntries } from './news.js';
 import { Plan, RafError, STATUSES } from './plan.js';
 import { schedule } from './schedule.js';
 import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.js';
 import { sessionClose, sessionStart } from './session.js';
-import { clearNext, readNext, sharedStateDir, stateDir, writeNext } from './state.js';
+import { clearNext, lastDelivery, readNext, sharedStateDir, stateDir, writeNext } from './state.js';
 const HELP = `raf — plan « reste à faire » versionné dans le dépôt, relié aux commits
 
   raf init [--project nom] [--prefix L] [--no-hook]
@@ -32,10 +33,14 @@ 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 gantt [-o docs/plan/gantt.html]
   raf hook install
+  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 … »)
 
 Un commit appartient à un lot quand son message cite l'identifiant : « feat(L3): … », « L3/t1 ».
-Un commit qui ne touche que le plan (et les fichiers déclarés sous plan.files dans cadence.yaml, un plan
+Quand la portée du sujet cite des lots — « feat(L3): … », « chore(L31,L32): … » — elle seule décide : une
+mention en passage (« page équipe (L27) »), une plage (« L28–L31 », « L45 à L48 ») ou le corps n'y comptent pas.
+Sans portée citant un lot, tout le message est lu : « fix: L3 corrigé », « L3/t1 ».
+Un commit qui ne touche que le plan, la clé plan: de cadence.yaml (deliver/session sont du travail) (et les fichiers déclarés sous plan.files, un plan
 publié par exemple) n'a pas à en citer, et ne compte pas pour les lots qu'il cite ; le sujet n'y change rien.
 Un lot --visible attend une entrée Nouveautés (docs/nouveautes/, --dir) avec capture ; raf check le vérifie.
 Un texte qui commence par « - » se passe après « -- » : raf note L1 -- "-5 %".
@@ -87,6 +92,7 @@ function dispatch(argv, io) {
             config: { type: 'string' },
             'dry-run': { type: 'boolean' },
             sha: { type: 'string' },
+            retry: { type: 'string' },
             clear: { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
         },
@@ -106,7 +112,7 @@ function dispatch(argv, io) {
     const installing = command === 'skills' || (command === 'hook' && rest[0] === 'install');
     const planConfig = installing ? null : readPlanConfig(configPath);
     const planPath = resolve(io.cwd, values.file ?? io.env.RAF_FILE ?? resolve(root, planConfig?.path ?? 'docs/plan/raf.yaml'));
-    const loadPlan = () => Plan.load(planPath, planConfig?.settings);
+    const loadPlan = () => Plan.load(planPath, { ...planConfig?.settings, config: configPath });
     const newsDir = resolve(io.cwd, values.dir ?? join(root, 'docs/nouveautes'));
     const need = (n, usage) => {
         if (rest.length < n)
@@ -231,7 +237,14 @@ function dispatch(argv, io) {
                 throw new RafError('session : à lancer dans un dépôt git');
             // « next » n'écrit que les notes : la commande du projet ne se joue qu'à la reprise et à la clôture.
             const facts = rest[0] === 'start' || rest[0] === 'close' ? readSessionConfig(configPath)[rest[0]] : undefined;
-            return session(rest, { plan: loadPlan(), root, newsDir, state: stateDir(root), shared: sharedStateDir(root), today, out: io.out, facts }, values);
+            const sctx = { plan: loadPlan(), root, newsDir, state: stateDir(root), shared: sharedStateDir(root), today, out: io.out, facts };
+            if (rest[0] !== 'start')
+                return session(rest, sctx, values);
+            // La reprise rejoue les vérifications d'effet (un essai, borné) : un effet rouge d'hier se lit avec les faits du matin.
+            const effects = morningEffects(configPath, root);
+            if (effects === null)
+                return session(rest, sctx, values);
+            return Promise.resolve(effects).then((lines) => session(rest, { ...sctx, effects: lines }, values));
         }
         case 'deliver': {
             if (!gitRoot(io.cwd))
@@ -243,6 +256,20 @@ function dispatch(argv, io) {
             const ctx = { root, state: sharedStateDir(root), plan, config, today, dryRun: !!values['dry-run'], sha: values.sha, args: rest, out: io.out, err: io.err };
             return deliver(ctx, realDeps(root));
         }
+        case 'verify': {
+            if (!gitRoot(io.cwd))
+                throw new RafError('verify : à lancer dans un dépôt git');
+            if (!existsSync(configPath))
+                throw new RafError(`pas de configuration : ${configPath} (voir « cadence.yaml » dans le README)`);
+            const retry = values.retry === undefined ? 0 : Number(values.retry);
+            if (!Number.isFinite(retry) || retry < 0)
+                throw new RafError(`--retry invalide : ${values.retry} (secondes, 0 ou plus)`);
+            const config = parseDeliverConfig(readFileSync(configPath, 'utf8'), configPath);
+            const sha = values.sha ? (resolveCommit(root, values.sha) ?? '') : (lastDelivery(sharedStateDir(root)) ?? headSha(root) ?? '');
+            if (values.sha && !sha)
+                throw new RafError(`--sha ${values.sha} : commit introuvable`);
+            return verifyCommand({ config, sha, retry, out: io.out }, realCheckDeps(root));
+        }
         case 'skills': {
             if (rest[0] !== 'install')
                 throw new RafError('usage : cadence skills install [--dir .claude] [--force]');
@@ -345,7 +372,7 @@ function postCommit(load, newsDir, root, io) {
         const head = readCommits(root, { range: '-1' })[0];
         if (!head)
             return 0;
-        const refs = plan.refs(`${head.subject}\n${head.body}`);
+        const refs = citedRefs(head, plan.refs);
         if (refs.length === 0) {
             const planOnly = exemptPlanOnly({ byLot: new Map(), orphans: [head], unknown: [] }, plan, root).orphans.length === 0;
             if (!planOnly && !/^Merge\b/.test(head.subject)) {
@@ -422,6 +449,27 @@ function news([sub, ...args], plan, dir, today, values, io) {
             throw new RafError('usage : cadence news new|list|check|stamp|build');
     }
 }
+/**
+ * Reprise : lignes d'effets à rejouer, ou null quand il n'y a rien à vérifier (sans cadence.yaml, sans deliver,
+ * script sans verify) — la reprise reste alors synchrone. Ne lève jamais.
+ */
+function morningEffects(configPath, root) {
+    if (!existsSync(configPath))
+        return null;
+    const text = readFileSync(configPath, 'utf8');
+    if (!/^deliver\s*:/m.test(text))
+        return null;
+    try {
+        const config = parseDeliverConfig(text, configPath);
+        if (config.verify.length === 0)
+            return null;
+        const sha = lastDelivery(sharedStateDir(root)) ?? headSha(root) ?? '';
+        return effectLines(config, sha, realCheckDeps(root, { quiet: true }));
+    }
+    catch (e) {
+        return [`✗ ${e.message}`];
+    }
+}
 function session([sub, ...args], ctx, values) {
     switch (sub) {
         case 'start': {

package/dist/deliver.js

@@ -1,11 +1,16 @@
-import { execFileSync, spawnSync } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
+import { constants } from 'node:os';
 import { parse } from 'yaml';
+import { onTermination, SIGNAL_GRACE_MS, TreeTracker } from './proc.js';
+import { isPlanOnly } from './audit.js';
 import { headSha, isAncestor, onRemote, readCommits, repoStatus, resolveCommit } from './git.js';
+import { citedRefs } from './link.js';
 import { RafError } from './plan.js';
 import { appendDelivery, lastDelivery, lockAlive, lockPath, readLock, releaseLock, removeStaleLock, writeLock } from './state.js';
 const POLL_CI = 15_000;
 const CI_APPEAR = 300_000;
-const POLL_VERIFY = 10_000;
+/** Intervalle de réessai d'une vérification : celui de deliver ET de `cadence verify --retry`. */
+export const POLL_VERIFY = 10_000;
 const CI_OK = new Set(['success', 'skipped', 'neutral']);
 const GH_TIMEOUT = 60_000;
 export const TIMED_OUT = 124;
@@ -106,18 +111,50 @@ export function realDeps(root) {
         }
     };
     return {
-        exec: (cmd, env, timeoutMs) => {
-            const r = spawnSync('sh', ['-c', cmd], {
+        exec: (cmd, env, timeoutMs) => new Promise((resolve) => {
+            const child = spawn('sh', ['-c', cmd], {
                 cwd: root,
                 env: { ...process.env, ...env },
                 stdio: ['ignore', 'inherit', 'inherit'],
-                timeout: Math.max(1_000, timeoutMs),
-                killSignal: 'SIGKILL',
+                // PAS de groupe détaché : la commande reste dans le groupe de premier plan et la session de cadence.
+                // Ctrl-C et le raccrochage l'atteignent avec cadence, et /dev/tty reste là pour ssh, sudo, pinentry.
             });
-            if (r.error?.code === 'ETIMEDOUT' || r.signal)
-                return TIMED_OUT;
-            return r.status ?? 1;
-        },
+            const pid = child.pid;
+            if (pid === undefined) {
+                child.once('error', () => resolve(127));
+                return;
+            }
+            // L'arbre de la commande est suivi pendant toute son exécution (relevé périodique, pid + heure de
+            // démarrage) : un enfant dont le parent meurt reste connu. Au délai, ou si cadence est tué (Ctrl-C,
+            // SIGTERM, raccrochage), TOUS les processus suivis encore vivants meurent avant que cadence ne rende la
+            // main ou ne meure — sh fait un fork par commande, et un descendant survivant livrerait encore pendant
+            // qu'une seconde livraison prend le verrou libéré ou périmé. Ctrl-C et raccrochage : l'arbre a déjà
+            // reçu le signal du terminal, un court délai de grâce laisse finir ses trap (et git son index.lock)
+            // avant le kill ; SIGTERM (à cadence seul) et le délai : kill immédiat.
+            const tree = new TreeTracker(pid);
+            // Terminaison en cours : exec ne rend pas la main avant qu'elle ne soit finie — sinon deliver libère
+            // le verrou pendant la grâce, alors que des descendants tournent encore.
+            let ending = null;
+            const forget = onTermination((sig) => (ending = sig === 'SIGTERM' ? Promise.resolve(tree.kill()) : tree.end(SIGNAL_GRACE_MS)));
+            let timedOut = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                tree.kill();
+            }, Math.max(1_000, timeoutMs));
+            child.once('exit', (code, signal) => {
+                clearTimeout(timer);
+                const result = timedOut ? TIMED_OUT : signal ? 128 + (constants.signals[signal] ?? 0) : (code ?? 1);
+                const settle = () => {
+                    tree.stop();
+                    forget();
+                    resolve(result);
+                };
+                if (ending)
+                    void ending.then(settle);
+                else
+                    settle();
+            });
+        }),
         gh: (sha) => JSON.parse(gh(['run', 'list', '--commit', sha, '--json', 'name,status,conclusion'])),
         ghReady: () => {
             try {
@@ -128,8 +165,8 @@ export function realDeps(root) {
                 return e.message;
             }
         },
-        fetch: async (url) => {
-            const res = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(20_000) });
+        fetch: async (url, timeoutMs = 20_000) => {
+            const res = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(Math.max(1_000, Math.min(20_000, timeoutMs))) });
             return { status: res.status, text: await res.text() };
         },
         sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
@@ -143,7 +180,7 @@ function substitute(text, sha) {
 function shellQuote(arg) {
     return /^[A-Za-z0-9_@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'\\''`)}'`;
 }
-function describeCheck(c, sha) {
+export function describeCheck(c, sha) {
     if (c.command !== undefined)
         return c.command;
     return `GET ${substitute(c.url, sha)} → ${c.status ?? 200}${c.contains === undefined ? '' : `, contient « ${substitute(c.contains, sha)} »`}`;
@@ -217,7 +254,7 @@ export async function deliver(ctx, deps) {
         out(`Livraison de ${env.CADENCE_SHORT} (${branch})`);
         if (script !== null) {
             out(`→ script du projet : ${script}`);
-            const code = deps.exec(script, env, config.deployTimeout * 1000);
+            const code = await deps.exec(script, env, config.deployTimeout * 1000);
             if (code !== 0)
                 return fail(`script de livraison en échec (${codeText(code)}) : ${script}`);
         }
@@ -227,7 +264,7 @@ export async function deliver(ctx, deps) {
                 return fail(ci);
             for (const [i, cmd] of config.deploy.entries()) {
                 out(`→ déploiement ${i + 1}/${config.deploy.length} : ${cmd}`);
-                const code = deps.exec(cmd, env, config.deployTimeout * 1000);
+                const code = await deps.exec(cmd, env, config.deployTimeout * 1000);
                 if (code !== 0)
                     return fail(`déploiement en échec (${codeText(code)}) : ${cmd}`);
             }
@@ -261,7 +298,7 @@ async function waitCi(ctx, deps, sha, env) {
         return null;
     if (typeof ci === 'object') {
         ctx.out(`→ CI : ${ci.command}`);
-        const code = deps.exec(ci.command, env, ciTimeout * 1000);
+        const code = await deps.exec(ci.command, env, ciTimeout * 1000);
         return code === 0 ? null : `CI en échec (${codeText(code)}) : ${ci.command}`;
     }
     ctx.out(`→ CI : attente des runs GitHub de ${sha.slice(0, 7)}`);
@@ -306,13 +343,14 @@ async function waitCi(ctx, deps, sha, env) {
         await deps.sleep(POLL_CI);
     }
 }
-async function tryCheck(c, deps, sha, env, budgetMs) {
+/** Un essai d'une vérification : cause de l'échec, ou null. Partagé par deliver et `cadence verify`. */
+export async function tryCheck(c, deps, sha, env, budgetMs) {
     if (c.command !== undefined) {
-        const code = deps.exec(c.command, env, budgetMs);
+        const code = await deps.exec(c.command, env, budgetMs);
         return code === 0 ? null : codeText(code);
     }
     try {
-        const res = await deps.fetch(substitute(c.url, sha));
+        const res = await deps.fetch(substitute(c.url, sha), budgetMs);
         const want = c.status ?? 200;
         if (res.status !== want)
             return `statut ${res.status} (attendu ${want})`;
@@ -324,22 +362,32 @@ async function tryCheck(c, deps, sha, env, budgetMs) {
         return `erreur réseau : ${e.message}`;
     }
 }
+/**
+ * UNE boucle de réessai, pour deliver et pour `cadence verify` : essaie, puis réessaie toutes les POLL_VERIFY
+ * tant que `until` n'est pas atteint. `attemptMs()` donne le délai de chaque essai. Rend la dernière cause
+ * d'échec, ou null dès que l'effet est celui attendu.
+ */
+export async function retryCheck(c, deps, sha, env, until, attemptMs) {
+    for (;;) {
+        const reason = await tryCheck(c, deps, sha, env, attemptMs());
+        if (reason === null)
+            return null;
+        const left = until - deps.now();
+        if (left <= 0)
+            return reason;
+        // jamais au-delà du délai : une commande tuée « à l'échéance » peut rendre la main un rien avant elle
+        await deps.sleep(Math.min(POLL_VERIFY, left));
+    }
+}
 /** Chaque vérification est réessayée jusqu'au délai commun ; message d'échec ou null. */
 async function verifyAll(ctx, deps, sha, env) {
     const deadline = deps.now() + ctx.config.verifyTimeout * 1000;
     for (const [i, c] of ctx.config.verify.entries()) {
         const label = describeCheck(c, sha);
         ctx.out(`→ vérification ${i + 1}/${ctx.config.verify.length} : ${label}`);
-        for (;;) {
-            const reason = await tryCheck(c, deps, sha, env, deadline - deps.now());
-            if (reason === null)
-                break;
-            const left = deadline - deps.now();
-            if (left <= 0)
-                return `vérification en échec après ${ctx.config.verifyTimeout} s : ${label} — ${reason}`;
-            // jamais au-delà du délai : une commande tuée « à l'échéance » peut rendre la main un rien avant elle
-            await deps.sleep(Math.min(POLL_VERIFY, left));
-        }
+        const reason = await retryCheck(c, deps, sha, env, deadline, () => deadline - deps.now());
+        if (reason !== null)
+            return `vérification en échec après ${ctx.config.verifyTimeout} s : ${label} — ${reason}`;
     }
     return null;
 }
@@ -361,7 +409,9 @@ function deliveredLots(ctx, prev, sha) {
     const known = new Set((ctx.plan.readonly ? lots.filter((l) => l.status === 'doing') : lots).map((l) => l.id));
     const ids = new Set();
     for (const c of readCommits(ctx.root, { range: `${prev}..${sha}` })) {
-        for (const r of ctx.plan.refs(`${c.subject}\n${c.body}`))
+        if (isPlanOnly(c.sha, ctx.plan, ctx.root))
+            continue; // entretien du plan : ne livre rien, même s'il cite des lots
+        for (const r of citedRefs(c, ctx.plan.refs))
             if (known.has(r.lot))
                 ids.add(r.lot);
     }

package/dist/git.js

@@ -45,9 +45,19 @@ 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 modifiés par un commit, relatifs à la racine du dépôt. */
+/** Fichiers modifiés par un commit, relatifs à la racine du dépôt (noms accentués ou à espaces compris). */
 export function changedFiles(cwd, sha) {
-    return git(cwd, ['diff-tree', '--root', '--no-commit-id', '--name-only', '-r', sha]).split('\n').filter(Boolean);
+    // -z : noms séparés par NUL, jamais échappés ; quotepath=off en plus pour les sorties qui citeraient quand même.
+    return git(cwd, ['-c', 'core.quotepath=off', 'diff-tree', '--root', '--no-commit-id', '--name-only', '-r', '-z', sha]).split('\0').filter(Boolean);
+}
+/** Contenu d'un fichier à un commit (`<sha>^` pour l'état d'avant) ; null s'il n'existe pas à ce commit. */
+export function fileAt(cwd, rev, file) {
+    try {
+        return git(cwd, ['show', `${rev}:${file}`]);
+    }
+    catch {
+        return null;
+    }
 }
 function tryGit(cwd, args) {
     try {

package/dist/link.js

@@ -1,6 +1,20 @@
 export function isMerge(c) {
     return /^Merge\b/.test(c.subject);
 }
+/** Portée d'un sujet « type(L24,L25)! : … » ; null sans parenthèses. */
+function scopeOf(subject) {
+    return /^[\w-]+\(([^)]*)\)!?\s*:/.exec(subject)?.[1] ?? null;
+}
+/**
+ * Références qui décident à quels lots appartient un commit : celles de la portée « type(L24) » quand elle
+ * en cite ; sinon, celles du message entier. Les mentions en passage (« page équipe (L27) »), les plages
+ * (« L28–L31 ») et le corps du message ne comptent donc pas dès que la portée désigne les lots.
+ */
+export function citedRefs(c, refsOf) {
+    const scope = scopeOf(c.subject);
+    const scoped = scope === null ? [] : refsOf(scope);
+    return scoped.length > 0 ? scoped : refsOf(`${c.subject}\n${c.body}`);
+}
 /** `refs` lit les références d'un message : `plan.refs`. */
 export function linkCommits(lots, commits, refsOf) {
     const ids = new Set(lots.map((l) => l.id));
@@ -9,7 +23,7 @@ export function linkCommits(lots, commits, refsOf) {
     const orphans = [];
     const unknown = [];
     for (const c of commits) {
-        const refs = refsOf(`${c.subject}\n${c.body}`);
+        const refs = citedRefs(c, refsOf);
         if (refs.length === 0) {
             if (!isMerge(c))
                 orphans.push(c);

package/dist/plan.js

@@ -122,6 +122,10 @@ export class Plan {
         }
         return { patterns, invalid };
     }
+    /** Fichier de configuration lu pour ce plan, null quand on n'en connaît pas (cadence.yaml à la racine alors). */
+    get configFile() {
+        return this.settings.config ?? null;
+    }
     /** Fichiers tenus avec le plan, relatifs à la racine du dépôt. */
     get files() {
         return this.settings.files ?? [];

package/dist/proc.js

@@ -0,0 +1,161 @@
+import { execFileSync } from 'node:child_process';
+import { readdirSync, readFileSync } from 'node:fs';
+/**
+ * Signaux qui terminent cadence pendant qu'une commande tourne : chaque commande en cours inscrit son
+ * nettoyage, cadence l'exécute avant de sortir — tué par le même signal, comme sans nettoyage.
+ */
+const SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+const cleanups = new Set();
+let dying = false;
+/**
+ * Délai de grâce après Ctrl-C ou raccrochage : l'arbre de la commande a déjà reçu le signal du terminal,
+ * ses `trap` et le nettoyage de git (index.lock) ont ce temps pour finir avant le kill.
+ */
+export const SIGNAL_GRACE_MS = 2_000;
+async function onSignal(sig) {
+    if (dying)
+        return; // un second signal pendant le nettoyage n'interrompt rien
+    dying = true;
+    await Promise.all([...cleanups].map((f) => f(sig)));
+    cleanups.clear();
+    for (const s of SIGNALS)
+        process.removeListener(s, onSignal);
+    process.kill(process.pid, sig);
+}
+/**
+ * Inscrit un nettoyage à faire si cadence reçoit Ctrl-C, SIGTERM ou le raccrochage ; rend son retrait.
+ * Le nettoyage peut être asynchrone : cadence l'attend avant de mourir du signal.
+ */
+export function onTermination(cleanup) {
+    if (cleanups.size === 0)
+        for (const s of SIGNALS)
+            process.on(s, onSignal);
+    cleanups.add(cleanup);
+    return () => {
+        if (dying || !cleanups.delete(cleanup))
+            return;
+        if (cleanups.size === 0)
+            for (const s of SIGNALS)
+                process.removeListener(s, onSignal);
+    };
+}
+function signal(pid, sig) {
+    try {
+        process.kill(pid, sig);
+        return true;
+    }
+    catch {
+        return false; // déjà mort
+    }
+}
+/** Tous les processus visibles : /proc sous Linux (starttime, champ 22 de stat), `ps` ailleurs (lstart). */
+function readProcs() {
+    const procs = new Map();
+    let names = null;
+    try {
+        names = readdirSync('/proc').filter((n) => /^\d+$/.test(n));
+    }
+    catch {
+        // pas de /proc (macOS) : ps
+    }
+    if (names) {
+        for (const n of names) {
+            try {
+                const stat = readFileSync(`/proc/${n}/stat`, 'utf8');
+                // « pid (comm) état ppid … starttime … » — comm peut contenir espaces et parenthèses
+                const f = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+                procs.set(Number(n), { ppid: Number(f[1]), start: f[19], zombie: f[0] === 'Z' });
+            }
+            catch {
+                // sorti entre-temps
+            }
+        }
+    }
+    else {
+        for (const line of execFileSync('ps', ['-A', '-o', 'pid=,ppid=,stat=,lstart='], { encoding: 'utf8' }).trim().split('\n')) {
+            const [pid, ppid, stat, ...lstart] = line.trim().split(/\s+/);
+            procs.set(Number(pid), { ppid: Number(ppid), start: lstart.join(' '), zombie: stat.startsWith('Z') });
+        }
+    }
+    return procs;
+}
+/** Intervalle du relevé des descendants d'une commande de deliver pendant qu'elle tourne. */
+export const TRACK_INTERVAL_MS = 200;
+/**
+ * Suivi continu de l'arbre d'une commande : toutes les TRACK_INTERVAL_MS, ses descendants sont relevés et
+ * chacun est retenu avec son heure de démarrage. Un processus vu une fois reste suivi même si son parent
+ * meurt (rattaché à init, il n'est plus sous la racine) — ses propres enfants aussi. Un pid suivi n'est
+ * signalé que si son heure de démarrage est toujours la même : jamais un pid réutilisé par un autre.
+ * Échappe seulement ce qui quitte l'arbre entre deux relevés (fork puis mort du parent en moins d'un
+ * intervalle) et ce que cadence n'a pas le droit de tuer (sudo).
+ */
+export class TreeTracker {
+    known = new Map();
+    timer;
+    constructor(root) {
+        const info = readProcs().get(root);
+        if (info)
+            this.known.set(root, info.start);
+        this.timer = setInterval(() => this.scan(), TRACK_INTERVAL_MS);
+        this.timer.unref();
+    }
+    /** Arrête le relevé périodique (la commande est finie, ou son arbre est tué). */
+    stop() {
+        clearInterval(this.timer);
+    }
+    /** Relève les nouveaux descendants des processus suivis encore vivants ; rend le relevé. */
+    scan(procs = readProcs()) {
+        for (let grew = true; grew;) {
+            grew = false;
+            for (const [pid, info] of procs) {
+                if (this.known.has(pid) || !this.isTracked(info.ppid, procs))
+                    continue;
+                this.known.set(pid, info.start);
+                grew = true;
+            }
+        }
+        return procs;
+    }
+    /** Processus suivis encore vivants (même heure de démarrage, pas zombies). */
+    alive(procs = this.scan()) {
+        return [...this.known.keys()].filter((pid) => this.isTracked(pid, procs) && !procs.get(pid).zombie);
+    }
+    isTracked(pid, procs) {
+        const start = this.known.get(pid);
+        return start !== undefined && procs.get(pid)?.start === start;
+    }
+    /**
+     * Tue tous les processus suivis encore vivants et TOUS leurs descendants actuels, sans en laisser filer un :
+     * chacun est d'abord arrêté (SIGSTOP) — plus aucun fork, et plus aucun enfant rattaché à init par la mort
+     * de son parent —, l'arbre est relu jusqu'à ce qu'il ne s'y ajoute plus rien, puis tout est tué (SIGKILL).
+     */
+    kill() {
+        this.stop();
+        const seen = new Set([process.pid]);
+        const stopped = [];
+        for (let fresh = this.alive(); fresh.length > 0;) {
+            for (const pid of fresh) {
+                seen.add(pid); // essayé une fois : mort entre-temps ou hors d'atteinte (sudo), il ne revient pas
+                if (signal(pid, 'SIGSTOP'))
+                    stopped.push(pid);
+            }
+            const procs = this.scan();
+            fresh = this.alive(procs).filter((pid) => !seen.has(pid));
+        }
+        for (const pid of stopped)
+            signal(pid, 'SIGKILL');
+    }
+    /**
+     * Laisse à l'ensemble suivi jusqu'à `graceMs` pour finir de lui-même (il a déjà reçu le signal du terminal),
+     * puis tue ce qui reste. Rend la main dès que plus aucun processus suivi n'est vivant.
+     */
+    async end(graceMs) {
+        this.stop();
+        const deadline = Date.now() + graceMs;
+        while (this.alive().length > 0) {
+            if (Date.now() >= deadline)
+                return this.kill();
+            await new Promise((r) => setTimeout(r, 50));
+        }
+    }
+}

package/dist/session.js

@@ -107,6 +107,7 @@ export function sessionStart(ctx, opts) {
     section(out, `Fait depuis ${opts.since}`, done);
     section(out, 'Écarts (raf check)', audit(plan, ctx.root, ctx.newsDir, today).map((i) => `✗ ${i.message}`));
     section(out, 'Dépôt', [repoLine(ctx.root).line]);
+    section(out, 'Effets en production (cadence verify)', ctx.effects ?? []);
     section(out, 'Faits propres au projet', projectFacts(ctx, opts.since));
     const proposals = [
         ...doing.map((l) => ({ l, why: 'en cours' })),

package/dist/verify.js

@@ -0,0 +1,114 @@
+import { spawn } from 'node:child_process';
+import { constants } from 'node:os';
+import { onTermination } from './proc.js';
+import { describeCheck, realDeps, retryCheck, TIMED_OUT } from './deliver.js';
+function killGroup(pgid, sig) {
+    try {
+        process.kill(-pgid, sig);
+    }
+    catch {
+        // groupe déjà vide
+    }
+}
+/**
+ * Une commande de vérification, en groupe de processus détaché (nouvelle session, sans tty) : au délai,
+ * TOUT le groupe est tué (aucun enfant orphelin) ; un signal reçu par cadence lui est relayé. Asynchrone :
+ * les vérifications tournent en parallèle. Réservé aux vérifications (verify, session start) — jamais
+ * aux commandes de deliver, qui gardent le groupe de premier plan et le tty.
+ */
+function execGroup(root, cmd, env, timeoutMs, quiet) {
+    return new Promise((resolve) => {
+        const child = spawn('sh', ['-c', cmd], {
+            cwd: root,
+            env: { ...process.env, ...env },
+            stdio: quiet ? 'ignore' : ['ignore', 'inherit', 'inherit'],
+            detached: true,
+        });
+        const pgid = child.pid;
+        if (pgid === undefined) {
+            child.once('error', () => resolve(127));
+            return;
+        }
+        // Ctrl-C, SIGTERM ou raccrochage reçu par cadence : relayé au groupe avant de sortir.
+        const forget = onTermination((sig) => killGroup(pgid, sig));
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            killGroup(pgid, 'SIGKILL');
+        }, timeoutMs);
+        child.once('exit', (code, signal) => {
+            clearTimeout(timer);
+            forget();
+            if (timedOut)
+                killGroup(pgid, 'SIGKILL'); // sh mort avant ses enfants : le groupe est vidé quand même
+            resolve(timedOut ? TIMED_OUT : signal ? 128 + (constants.signals[signal] ?? 0) : (code ?? 1));
+        });
+    });
+}
+/** Dépendances réelles des vérifications. `quiet` : sortie des commandes non relayée (rapport de session start). */
+export function realCheckDeps(root, opts = {}) {
+    const { fetch, sleep, now } = realDeps(root);
+    return { fetch, sleep, now, exec: (cmd, env, timeoutMs) => execGroup(root, cmd, env, timeoutMs, !!opts.quiet) };
+}
+/**
+ * Rejoue des vérifications d'effet, TOUTES EN PARALLÈLE : chaque essai reçoit le budget entier
+ * (`attemptMs`, tuée au-delà : « délai dépassé »), une vérification lente ne prend rien aux autres.
+ * UNE passe par défaut ; avec `retryMs`, chacune est réessayée de son côté (toutes les POLL_VERIFY)
+ * jusqu'à ce délai. Durée totale bornée par retryMs + attemptMs. Résultats dans l'ordre des vérifications.
+ * Le code d'une vérification est celui de deliver (tryCheck/retryCheck) : aucune règle n'est dupliquée.
+ */
+export async function replayChecks(checks, deps, sha, env, opts) {
+    const until = deps.now() + opts.retryMs;
+    return Promise.all(checks.map(async (c) => ({ label: describeCheck(c, sha), reason: await retryCheck(c, deps, sha, env, until, () => opts.attemptMs) })));
+}
+export const resultLine = (r) => (r.reason === null ? `✓ ${r.label}` : `✗ ${r.label} — ${r.reason}`);
+export function summaryLine(results) {
+    const red = results.filter((r) => r.reason !== null).length;
+    const n = results.length;
+    return red === 0
+        ? `verify : ${n}/${n} vérifications vertes`
+        : `verify : ${red} effet${red > 1 ? 's' : ''} rouge${red > 1 ? 's' : ''} sur ${n} vérification${n > 1 ? 's' : ''}`;
+}
+/** Variables passées aux commandes de vérification, comme à celles de deliver. */
+export function verifyEnv(sha) {
+    return { CADENCE_SHA: sha, CADENCE_SHORT: sha.slice(0, 7), CADENCE_BRANCH: '' };
+}
+/** Délai de chaque essai d'une vérification de `cadence verify`. */
+export const VERIFY_ATTEMPT_MS = 120_000;
+/** `cadence verify` : 0 tout vert, 1 un effet rouge, 2 rien à vérifier. */
+export async function verifyCommand(ctx, deps) {
+    const { config, out } = ctx;
+    if (config.verify.length === 0) {
+        out(config.script !== undefined
+            ? 'verify : aucune vérification déclarée — ce projet livre par son script (deliver.script) et ses contrôles sont les siens ; ' +
+                'déclarer deliver.verify dans cadence.yaml pour les rejouer hors livraison'
+            : 'verify : aucune vérification déclarée (deliver.verify)');
+        return 2;
+    }
+    const results = await replayChecks(config.verify, deps, ctx.sha, verifyEnv(ctx.sha), { retryMs: ctx.retry * 1000, attemptMs: VERIFY_ATTEMPT_MS });
+    for (const r of results)
+        out(resultLine(r));
+    out(summaryLine(results));
+    return results.some((r) => r.reason !== null) ? 1 : 0;
+}
+/**
+ * Délai de chaque vérification de « session start », lancées en parallèle : c'est aussi, à la mise à mort
+ * près, la durée totale — la reprise ne doit pas attendre un réseau absent.
+ */
+export const MORNING_BUDGET_MS = 10_000;
+/**
+ * Lignes « Effets en production » du rapport de reprise : un seul essai par vérification, borné. Rien à dire
+ * (liste vide) pour un projet sans verify ; ne lève jamais — c'est un fait de plus, pas une condition.
+ */
+export async function effectLines(config, sha, deps) {
+    if (config.verify.length === 0)
+        return [];
+    try {
+        const results = await replayChecks(config.verify, deps, sha, verifyEnv(sha), { retryMs: 0, attemptMs: MORNING_BUDGET_MS });
+        const shown = results.filter((r) => r.reason !== null);
+        return shown.length === 0 ? [`✓ ${summaryLine(results)}`] : [...shown.map(resultLine), summaryLine(results)];
+    }
+    catch (e) {
+        return [`✗ verify : ${e.message}`];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylad/cadence",
-  "version": "0.7.0",
+  "version": "0.8.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",
@@ -9,8 +9,18 @@
     "raf": "bin/raf.js",
     "cadence": "bin/cadence.js"
   },
-  "files": ["bin", "dist", "skills", "agents", ".claude-plugin", "README.md", "LICENSE"],
-  "engines": { "node": ">=20" },
+  "files": [
+    "bin",
+    "dist",
+    "skills",
+    "agents",
+    ".claude-plugin",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "test": "vitest run",

package/skills/session-start/SKILL.md

@@ -30,6 +30,9 @@ three most useful items across projects and wait. With a project named, work in
    - **Done since**: 3 to 6 lines, grouped by lot, not by commit. Mention commits without a lot.
    - **Drift**: each `✗` line from the check, with the one command that fixes it.
    - **Delivery in progress** or a stale lock: no new delivery until it is resolved.
+   - **Effects in production** ("Effets en production"): a red `✗` line is the first thing to say —
+     a delivered feature that no longer works outranks any new lot; re-run `cadence verify` to confirm
+     (a network blip also shows as red).
    - **Notes from the last close**, if any.
    - **Project facts** ("Faits propres au projet"), when the project plugs its own morning script in
      (`session.start` in `cadence.yaml`): summarise what bears on today's choice — deadlines, the