@sylad/cadence 1.24.0 → 1.26.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": "1.24.0",
+      "version": "1.26.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": "1.24.0",
+  "version": "1.26.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/README.md

@@ -52,7 +52,7 @@ Details: [docs/skills.md](docs/skills.md) and [docs/cadence-hud.md](docs/cadence
 - [docs/deliver.md](docs/deliver.md): wait for the CI, deploy, verify the effect.
 - [docs/spec.md](docs/spec.md): screen and back-end sheets.
 - [docs/ref.md](docs/ref.md): reference documents (specs, norms, mock-ups) and the coverage of their elements by the lots.
-- [docs/lead.md](docs/lead.md): the lead workflow.
+- [docs/lead.md](docs/lead.md): the lead workflow, and the `livreur` agent that delivers a ready lot for it.
 - [docs/overview.md](docs/overview.md): the longer introduction and the map of every page.
 - [docs/fonctionnement.md](docs/fonctionnement.md): how it all works, in four figures.
 - [docs/stabilite.md](docs/stabilite.md): what is guaranteed from 1.0.0.

package/agents/code-reviewer.md

@@ -91,6 +91,23 @@ A short report:
   in that one line: an empty list of findings is a valid review. It is the last line of the
   review; extra sections a caller asks for come after it.
 
+## Short reply
+
+Only when the brief carries a line `Report file: <absolute path>` (the lead, which keeps its context
+small by reading a report only when it needs to). That line is the only trigger; an orchestrated
+review session and a review started by hand have none.
+
+- The full report, as the Output section above describes it, is written to that file with Bash. Use the
+  path the brief gives and no other: it is outside the repository, so the working tree stays as you
+  found it. The verdict is the last line of the file. Write the file before you reply.
+- Reply to the caller with 5 lines at most, and nothing before or after them:
+  `Verdict: <the one-line verdict>`, `Blocking: <n> — <one short phrase per blocking finding>` (`Blocking: 0` when there is none),
+  `Follow-ups: <n> — <the lines to add to the plan, by their first words>` (`Follow-ups: 0` when there is none),
+  `Report: <the path>`. Add a fifth line, `Not verified: <n>`, only when something could not be run.
+- If you cannot write the file, say so on the first line of the reply and give the whole report in the reply, as if
+  the brief had no report file: a verdict whose evidence nobody can read is lost.
+- With no `Report file:` line in the brief, give the complete report in your reply.
+
 ## Do not
 
 - Judge on taste: naming, formatting or structure you would have written differently is not a

package/agents/livreur.md

@@ -0,0 +1,69 @@
+---
+name: livreur
+description: Delivery agent of the lead. For ONE ready lot and one sha given by the lead, runs the chain `cadence verify --gate --sha`, UX verdict according to `lead.ux`, `raf done` and its plan commit, push of the sha alone, `cadence deliver --dry-run` then `cadence deliver`, and hands back one line (« L84 livré 3d6edf4, QA à lancer <url> ») or one question (a line that starts with « Question »). Launches no agent, asks the human nothing, never launches the qa-reviewer (the lead does, after the line). Called by the lead, one delivery at a time per repository.
+tools: Read, Grep, Glob, Bash
+---
+
+You deliver one ready lot for the lead. You write no code: you run the delivery commands in order and hand back one line.
+
+## The brief
+
+You deliver ONE lot per launch: the lot of the brief, at the sha of the brief, never a second lot, and you never work out the « livrable jusqu'à » sha yourself (the lead gives it). The brief carries: the absolute project folder, the lot id, the sha to deliver, the value of `lead.ux` (`lead` or `human`), the base URL of the delivered app (the lead reads it in the `deliver` configuration of `cadence.yaml`), and, for a visible lot with `lead.ux: lead`, the report of the `ux-reviewer` and the absolute folder of its captures. Work in the project folder.
+
+You launch no agent and ask the human nothing: when something is ambiguous, you stop and hand it back to the lead as a question (see Questions).
+
+## Before any command
+
+Check the brief and the sha first. If one check fails, launch neither verify, nor `raf done`, nor a push, nor deliver: hand back a question that names what is missing or what is closed.
+
+1. Complete brief: project folder, lot id, sha, `lead.ux` value. Otherwise `Question : brief incomplet : <champ> absent`. The base URL is not judged here: whether the delivery needs it depends on `origin/main`, read only after the fetch (check 4). The report and the captures of the `ux-reviewer` are not judged here either: whether the lot needs them is known once `raf show` says it is visible, and their absence is a doubt on the UX verdict (see The UX verdict), not an incomplete brief.
+2. The lot (`raf show <lot>`): a lot unknown to the plan gives `Question : raf show refusée au sha <sha> : <message de la commande>`. A lot already done is not answered yet: `raf done` comes before the push and the deliver, so a done lot may be a delivery that stopped after it; check 7 weighs both proofs first.
+3. Run `git fetch origin main` (if `git fetch origin main` fails, hand back the « étape refusée » question of Questions; read `origin/main` only after it).
+4. The QA decision: `git diff --name-only origin/main..<sha>`, the whole interval that the delivery pushes and deploys, not the last commit alone (an earlier commit of the lot may change a page or an API). Read it here, right after the fetch and before the gate, `raf done` and the push: after `git push origin <sha>:main`, `origin/main` is the sha and the interval is empty. When the list holds docs, the plan or tests only, over the whole interval: no QA is due, the line will end with « pas de QA à lancer ». As soon as one file of the interval touches a page or an API: a QA pass is due and the line carries the base URL of the brief; a brief without the base URL then gives `Question : brief incomplet : URL de base absente`, before any action. Keep the decision for the line.
+5. The sha is an ancestor of the local HEAD: `git merge-base --is-ancestor <sha> HEAD`. Otherwise `Question : sha <sha> non livrable : pas un ancêtre de HEAD`.
+6. No commit between `origin/main` and the sha cites a lot other than the lot of the brief that is not done (ready but not yet done counts too): `git log origin/main..<sha>` and `raf show` of each lot cited. A commit that cites no lot, or the plan alone, passes. Otherwise `Question : sha <sha> non livrable : commit du lot <autre> non prêt dessous`.
+7. The sha is not already delivered. « Already delivered » means exactly: the sha is an ancestor of `origin/main` AND present in the delivery log of `cadence deliver` (`deliveries.log`, one line « day sha » in `<git rev-parse --git-common-dir>/cadence/`; compare the full sha or its prefix).
+   - Both proofs: `Question : <lot> déjà clos ou sha <sha> déjà livré (origin/main et journal)`: nothing left to do.
+   - Lot done and neither proof: say what is measured, never « déjà livré »: `Question : <lot> clos mais sha <sha> ni dans origin/main ni au journal : push et livraison restent à faire`; rerun nothing (`raf done` is already done, the push and the deliver are the lead's call).
+   - Only one of the two: say which proof is missing and rerun nothing: neither `raf done` nor `cadence deliver`. `Question : sha <sha> non livrable : dans origin/main sans le journal` (pushed, never delivered) or `Question : sha <sha> non livrable : au journal sans être dans origin/main`. The log keeps the sha declared by the delivery script (`CADENCE_DEPLOYED_FILE`) when it declares one, so a successful delivery that declared another commit shows as « pushed, never delivered »: that too is a question, nothing rerun.
+   - The lot being done does not change the choice of the message: it is picked from the two proofs, evaluated for a done lot too.
+   - A rerun after a successful delivery never does `raf done` again.
+
+## The chain
+
+In this order; no step is skipped or swapped.
+
+1. `cadence verify --gate --sha <sha>`. Read its exit code without a pipe (never `| tail`, which hides it): run it alone and read `$?`. Exit 0 (green): go on. Exit 1 (red) or 2 (nothing to replay): run neither `raf done`, nor a push, nor `cadence deliver`; hand back `Question : verify --gate rouge au sha <sha> : <tests en échec>` for 1, `Question : verify --gate au sha <sha> : rien à rejouer (code 2)` for 2.
+2. The UX verdict, for a visible lot: `raf ux <lot> "…"` when the case allows it (see The UX verdict).
+3. `raf done <lot>`. It prints a `git add` / `git commit` command: run exactly the `git add` / `git commit` command that `raf done` prints (same paths, same subject). If `raf done` warns « intégration en cours »: commit the plan at once, with no other write in the tree. Do not push the commit of the plan: it stays above `origin/main` for the lead, who pushes it after its own replay (the `pre-push` hook).
+4. `git push origin <sha>:main`: the sha alone, never `HEAD`.
+5. `cadence deliver --dry-run --sha <sha>`, then `cadence deliver --sha <sha>`.
+6. Hand back the line (see The line).
+
+Never `--force`, never `CADENCE_PUSH_UNGATED`, no second attempt after a refusal (`raf done`, `pre-push` hook exit 3, `cadence deliver`): stop and hand back `Question : <étape> refusée au sha <sha> : <message de la commande>`.
+
+## The UX verdict
+
+For a visible lot only, after the green gate and before `raf done`. Whether the lot is visible is read in `raf show <lot>`: a visible lot prints a line `visible : oui` (followed by `screen : …` when it has one) and a line `ux : <verdict>` or `ux : absent`; a lot that prints neither line is not visible, there is no UX verdict to form or to check: go on to `raf done`.
+
+- `lead.ux: lead`: open the captures yourself (read the images of the captures folder, one by one) and read the report of the `ux-reviewer`; do not trust the words of the report. Record `raf ux <lot> "…"` with the last line of the report brought up to date, only when the reviewer has no reservation left and the captures show what the lot promised.
+- At the slightest doubt (a reservation you cannot settle, a capture you cannot read, a layout or wording choice that is a matter of taste, a state the captures do not show): records no `raf ux`, closes nothing, hand back `Question : doute sur le verdict UX de <lot> : <réserve> (captures : <chemin>)`.
+- Report or captures missing from the brief, for a visible lot with `lead.ux: lead` (known once `raf show` prints `visible : oui`): the same doubt, one message only: records no `raf ux`, closes nothing, hand back `Question : doute sur le verdict UX de <lot> : rapport ou captures absents du brief (captures : <chemin reçu, ou aucun>)`. Never « brief incomplet » for them.
+- `lead.ux: human` (or no key): never form the verdict yourself. Read the `ux` line of `raf show <lot>`: `ux : <verdict>` says the human's verdict is recorded, go on; `ux : absent` says none is: close nothing and hand back `Question : verdict UX absent pour <lot> (lead.ux: human)`.
+
+## The line
+
+The last thing you hand back is one line, once the delivery is green. The base URL comes from the brief; never deduce or invent it.
+
+- Delivery that changes a page or an API: `<lot> livré <sha court>, QA à lancer <url>` (for instance `L84 livré 3d6edf4, QA à lancer https://app.example`).
+- Delivery that changes neither a page nor an API: `<lot> livré <sha court>, pas de QA à lancer`. The decision is the one of check 4 (`git diff --name-only origin/main..<sha>`, read after `git fetch origin main` and before the push: after `git push origin <sha>:main` the interval is empty): docs, the plan or tests only over the whole interval, no QA; as soon as one file of the interval touches a page or an API: the line carries the URL.
+
+You never launch the `qa-reviewer`: the lead launches it after your line, with the URL it carries.
+
+## Questions
+
+A question starts with « Question : » and fits in a few lines: the step reached, the sha, the cause and the command to rerun. It says the state of the repository left by that step (for instance « raf done fait, commit du plan non fait »): you leave it as the step reached left it, and do not clean up. A step that fails or is refused (`git fetch origin main`, `raf done`, the commit of the plan, the push, `cadence deliver`) is handed back as `Question : <étape> refusée au sha <sha> : <message de la commande>`.
+
+## Never
+
+Never change code, never `raf review`, never `raf start`, never `raf note`; `raf ux` only in the case of the UX verdict. Never push the plan, never `HEAD`, never `--force`, never `CADENCE_PUSH_UNGATED`. Never `git checkout` or `git switch` to another commit or branch in this repository. Launch no agent. Do not stop to ask the human anything: a question goes in your reply to the lead.

package/agents/qa-reviewer.md

@@ -169,6 +169,23 @@ Give screenshots and snapshots the absolute path of the capture directory your b
 the caller names; remove them, or list their paths in the report — except the QA browser profile, which is kept for the next pass. The working tree is left as you
 found it.
 
+## Short reply
+
+Only when the brief carries a line `Report file: <absolute path>` (the lead, which keeps its context
+small by reading a report only when it needs to). That line is the only trigger; an orchestrated
+review session and a review started by hand have none.
+
+- The full report, as the Output section above describes it, is written to that file with Bash. Use the
+  path the brief gives and no other: it is outside the repository, so the working tree stays as you
+  found it. The verdict is the last line of the file. Write the file before you reply.
+- Reply to the caller with 5 lines at most, and nothing before or after them:
+  `Verdict: <the one-line verdict>`, `Blocking: <n> — <one short phrase per blocking finding>` (`Blocking: 0` when there is none),
+  `Follow-ups: <n> — <the lines to add to the plan, by their first words>` (`Follow-ups: 0` when there is none),
+  `Report: <the path>`. Add a fifth line, `Not walked: <n> pages`, only when pages were not reached.
+- If you cannot write the file, say so on the first line of the reply and give the whole report in the reply, as if
+  the brief had no report file: a verdict whose evidence nobody can read is lost.
+- With no `Report file:` line in the brief, give the complete report in your reply.
+
 ## Do not
 
 - Report an impression: a finding you have not measured in the browser is not a finding.

package/dist/cli.js

@@ -59,7 +59,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf ux <id> "verdict" enregistre la revue d'ergonomie du lot (agent ux-reviewer)
   raf review enable     revue de code obligatoire avant « done » pour les lots qui ont des commits
   raf review <id> "verdict" enregistre la revue de code du lot (agent code-reviewer)
-  raf show <id> [--notes]   le lot : statut, dates, after, titre public, notes datées, commits comptés ; --notes : les notes seules
+  raf show <id> [--notes]   le lot : statut, dates, after, titre public, visible et verdict ux (lot visible), notes datées, commits comptés ; --notes : les notes seules
   raf commits <id>      les commits du lot que compte la porte de revue de code, du plus ancien au plus récent
   raf now               ce qui est en cours, la suite, les derniers terminés
   raf list [--status todo|doing|done|dropped]
@@ -632,8 +632,13 @@ function dispatch(argv, io) {
                 io.out(`after : ${lot.after.join(', ')}`);
             if (lot.public)
                 io.out(`public : ${lot.public}`);
+            // L439 : le livreur lit ici si le lot est visible et s'il porte un verdict UX ; deux lignes stables, absentes d'un lot non visible.
+            if (lot.visible)
+                io.out('visible : oui');
             if (lot.screen)
                 io.out(`screen : ${lot.screen}`);
+            if (lot.visible)
+                io.out(lot.ux ? `ux : ${lot.ux.verdict}` : 'ux : absent');
             if (lot.spec)
                 io.out('spec : true');
             if (lot.uses)
@@ -747,7 +752,7 @@ function dispatch(argv, io) {
             if (rest[0] === 'pre-commit')
                 return preCommit(existsSync(planPath) ? loadPlan : null, readHookConfig(configPath).autostart, root, today, io);
             if (rest[0] === 'pre-push')
-                return prePush(root, io, rest[1], configPath);
+                return prePush(root, io, rest[1], configPath, planFileIn(root, planPath));
             throw new RafError('usage : raf hook install|pre-commit|post-commit|pre-push');
         }
         case 'session': {
@@ -1128,13 +1133,17 @@ function morningEffects(configPath, root) {
         return [`✗ ${e.message}`];
     }
 }
+/** Le plan, relatif à la racine du dépôt git (comme les fichiers d'un commit), séparateurs `/`. */
+function planFileIn(root, planPath) {
+    return relative(gitRoot(root) ?? root, planPath).split('\\').join('/');
+}
 /**
  * `raf hook pre-push` (L405), appelé par le hook que la vague pose : refuse (code 3) un push qui emporte un commit d'un lot pas prêt de la vague vivante
  * du dépôt, ou dont un lot pas prêt a des commits illisibles (la garde de `deliver --sha`). Puis (L426), quand le projet déclare une porte, refuse un push dont
- * le sha de tête n'a pas de verdict vert de `cadence verify --gate` (`CADENCE_PUSH_UNGATED=1` passe outre, et le dit). Sans vague qui tient le dépôt, ou avec un état de vague illisible
+ * le sha de tête n'a pas de verdict vert de `cadence verify --gate` (`CADENCE_PUSH_UNGATED=1` passe outre, et le dit) ; un commit qui ne change que le plan reprend le verdict de son parent (L432). Sans vague qui tient le dépôt, ou avec un état de vague illisible
  * (avertissement), la première garde ne gêne jamais un push ; une config illisible laisse passer la seconde.
  */
-function prePush(root, io, remoteName, configPath) {
+function prePush(root, io, remoteName, configPath, planFile) {
     let input = '';
     try {
         input = io.stdin ? io.stdin() : readFileSync(0, 'utf8');
@@ -1165,7 +1174,7 @@ function prePush(root, io, remoteName, configPath) {
     catch {
         return 0;
     }
-    const refusal = gateRefusal(root, gate, input);
+    const refusal = gateRefusal(root, gate, input, planFile);
     if (!refusal)
         return 0;
     if (io.env[UNGATED_ENV] === '1') {
@@ -1603,7 +1612,16 @@ async function verifyGateCommand(values, io) {
     const sha = resolveCommit(top, values.sha);
     if (!sha)
         throw new RafError(`verify --gate : --sha ${values.sha} : commit introuvable dans ${top}`);
-    return verifyGate({ repo: top, sha, config: readOrchestrateConfig(configPath), verify: readVerifyConfig(configPath), launchDirs: [io.cwd, top, dirname(top)], now: io.now, out: io.out });
+    // Le plan du projet (L444) : les commits qui ne changent que lui au-dessus du sha reprennent la porte du sha dessous. Illisible, il n'est pas cherché : la porte se rejoue.
+    let planFile;
+    try {
+        const configured = readPlanConfig(configPath, top)?.path;
+        planFile = planFileIn(top, configured !== undefined ? resolve(top, configured) : defaultPlan(top).path);
+    }
+    catch {
+        planFile = undefined;
+    }
+    return verifyGate({ repo: top, sha, config: readOrchestrateConfig(configPath), verify: readVerifyConfig(configPath), launchDirs: [io.cwd, top, dirname(top)], planFile, now: io.now, out: io.out });
 }
 /** `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) {

package/dist/gate-record.js

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync, realpathSync } from 'node:fs';
+import { changedFiles, tryGit } from './git.js';
 import { git } from './orchestrate/worktree.js';
 import { RunStore } from './orchestrate/state.js';
 const realOrSelf = (p) => {
@@ -9,14 +10,36 @@ const realOrSelf = (p) => {
         return p;
     }
 };
+const PLAN_HOPS = 50;
+/**
+ * Les shas dont la porte vaut pour `sha` : `sha` lui-même, puis, tant que le commit ne change que le plan (`planFile`, relatif à la racine du dépôt) et n'a qu'un parent, son parent, de proche en proche
+ * (même règle que le hook pre-push, L432 : le commit de revue et celui de `raf done` posés au-dessus d'un lot intégré ne changent pas ce que la porte a contrôlé).
+ * Une fusion, un commit racine, un commit qui touche autre chose que le plan ou qui ne touche rien est le dernier de la liste.
+ */
+function planChain(repo, sha, planFile) {
+    const chain = [sha];
+    if (planFile === undefined)
+        return chain;
+    for (let hop = 0; hop < PLAN_HOPS; hop++) {
+        const at = chain[chain.length - 1];
+        const parents = (tryGit(repo, ['rev-list', '--parents', '-n1', at]) ?? '').trim().split(/\s+/).slice(1);
+        const files = parents.length === 1 ? changedFiles(repo, at) : [];
+        if (files.length !== 1 || files[0] !== planFile)
+            break;
+        chain.push(parents[0]);
+    }
+    return chain;
+}
 /**
  * La porte que le programme a déjà jouée pour `sha` (L397), pour que `verify --gate` la lise au lieu de la rejouer (≈ 5 min par lot prêt).
  * Une vague range l'état de ses lots sous `<dossier de lancement>/.cadence/runs/<vague>` : `launchDirs` sont ceux à regarder (dossier courant, racine du dépôt, son parent), les vagues les plus récentes d'abord.
  * Un enregistrement est repris quand ses contrôles ont tourné AU sha (même commit), que l'arbre de ce commit est celui enregistré, et qu'il couvre chaque étape de `steps`
- * (même étiquette, même commande, code 0 : une étape rouge, absente ou rejouée avec une autre commande ne prouve rien). Sinon `reason` dit pourquoi la porte est rejouée.
+ * (même étiquette, même commande, code 0 : une étape rouge, absente ou rejouée avec une autre commande ne prouve rien). `planFile` : les commits qui ne changent que le plan au-dessus de `sha` sont traversés (`planBase`, L444). Sinon `reason` dit pourquoi la porte est rejouée.
  */
-export function recordedGate(launchDirs, repo, sha, steps) {
-    const tree = git(repo, 'rev-parse', `${sha}^{tree}`);
+export function recordedGate(launchDirs, repo, sha, steps, planFile) {
+    const chain = planChain(repo, sha, planFile);
+    const trees = new Map();
+    const treeOf = (c) => trees.get(c) ?? trees.set(c, git(repo, 'rev-parse', `${c}^{tree}`)).get(c);
     const repoReal = realOrSelf(repo);
     let reason = 'aucune porte de vague enregistrée pour ce sha';
     const seen = new Set();
@@ -46,24 +69,27 @@ export function recordedGate(launchDirs, repo, sha, steps) {
                 continue; // état illisible (écriture en cours) : cette vague ne fournit rien
             }
             for (const l of lots) {
-                if (l.checks?.head !== sha || realOrSelf(l.repo) !== repoReal)
+                const checks = l.checks;
+                const checked = checks === undefined ? undefined : chain.find((c) => c === checks.head);
+                if (checks === undefined || checked === undefined || realOrSelf(l.repo) !== repoReal)
                     continue;
+                const tree = treeOf(checked);
                 const where = `vague ${store.id}, lot ${l.lot}`;
-                if (l.checks.tree === undefined) {
+                if (checks.tree === undefined) {
                     reason = `arbre non enregistré (${where}, enregistrement antérieur à L397)`;
                     continue;
                 }
-                if (l.checks.tree !== tree) {
+                if (checks.tree !== tree) {
                     reason = `arbre différent de celui contrôlé (${where})`;
                     continue;
                 }
                 const label = (name) => (name === 'build' ? 'build' : 'tests');
-                const missing = steps.filter((s) => !l.checks.runs.some((r) => r.label === label(s.name) && r.command === s.cmd && r.code === 0));
+                const missing = steps.filter((s) => !checks.runs.some((r) => r.label === label(s.name) && r.command === s.cmd && r.code === 0));
                 if (missing.length) {
                     reason = `l'enregistrement (${where}) ne couvre pas en vert ${missing.map((s) => `${s.name} (${s.cmd})`).join(', ')}`;
                     continue;
                 }
-                return { found: { wave: store.id, lot: l.lot, tree, runs: l.checks.runs } };
+                return { found: { wave: store.id, lot: l.lot, tree, checked, runs: checks.runs } };
             }
         }
     }

package/dist/git.js

@@ -1,5 +1,5 @@
 import { execFileSync } from 'node:child_process';
-import { rmSync, writeFileSync } from 'node:fs';
+import { readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { basename, dirname, resolve } from 'node:path';
 function git(cwd, args) {
     // Le journal complet d'un gros dépôt dépasse le Mo par défaut : sans marge, il serait lu comme vide.
@@ -248,6 +248,36 @@ export function dirtyPaths(root, paths) {
     const out = git(root, ['-c', 'core.quotepath=off', 'status', '--porcelain', '-z', '--', ...paths]);
     return out.split('\0').filter(Boolean).map((l) => l.slice(3));
 }
+/**
+ * L'état des fichiers que git voit modifiés, stagés ou non suivis dans tout le dépôt : chemin (relatif à la racine) → contenu.
+ * Deux états se comparent pour savoir ce qu'une commande a écrit entre les deux. Vide hors d'un dépôt git.
+ */
+export function dirtyContents(root) {
+    const state = new Map();
+    let out;
+    try {
+        out = git(root, ['-c', 'core.quotepath=off', 'status', '--porcelain', '-z', '-uall']);
+    }
+    catch {
+        return state;
+    }
+    const top = tryGit(root, ['rev-parse', '--show-toplevel'])?.trim() ?? root;
+    const entries = out.split('\0').filter(Boolean);
+    for (let i = 0; i < entries.length; i++) {
+        const file = entries[i].slice(3);
+        if (entries[i][0] === 'R' || entries[i][0] === 'C')
+            i++; // un renommage porte l'ancien chemin dans l'entrée suivante
+        let content = '';
+        try {
+            content = readFileSync(resolve(top, file)).toString('base64');
+        }
+        catch {
+            content = '(absent)';
+        }
+        state.set(file, content);
+    }
+    return state;
+}
 /** Commit de `paths` seuls (à chemin explicite : le reste de l'index n'y entre pas). Rend le sha court. Lève l'erreur de git (hook refusé compris). */
 export function commitPaths(root, paths, message) {
     git(root, ['add', '--', ...paths]);

package/dist/lead.js

@@ -71,7 +71,7 @@ export function openLots(lots) {
     return lots
         .filter((l) => isOpen(l.status) && !isRecurring(l))
         .flatMap((l) => [
-        { id: l.id, title: l.title, status: l.status, after: l.after, ...(l.parent ? { parent: l.parent } : {}) },
+        { id: l.id, title: l.title, status: l.status, after: l.after, ...(l.parent ? { parent: l.parent } : {}), ...(l.review ? { reviewed: true } : {}) },
         ...l.tasks.filter((t) => isOpen(t.status)).map((t) => ({ id: `${l.id}/${t.id}`, title: t.title, status: t.status, after: [], parent: l.id })),
     ]);
 }
@@ -146,6 +146,9 @@ export function tourRow(dir, today, idle = TOUR_IDLE, name = basename(dir)) {
             added7: counted.filter((l) => l.created !== undefined && diffDays(l.created, today) >= 0 && diffDays(l.created, today) < ADDED_DAYS).length,
         };
         row.lots = openLots(lots);
+        const closed = lots.filter((l) => l.status === 'done' && l.every === undefined && l.finished !== undefined).map((l) => ({ id: l.id, finished: l.finished }));
+        if (closed.length)
+            row.closed = closed;
         const waiting = gateWaiting(lots, blocked).map((g) => g.lot.id);
         if (waiting.length)
             row.waiting = waiting;