@sylad/cadence 1.23.0 → 1.25.1

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

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/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

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { basename, dirname, join, posix, relative, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
@@ -14,7 +14,7 @@ import { ganttData, renderGantt } from './gantt.js';
 import { PLAN_ACTIONS, planCommitMessage } from './plan-commit.js';
 import { dirtyPaths, gitRoot, isTracked, readCommits, matchesHead, resolveCommit, stage, stagedFiles, syncIndexWithHead } from './git.js';
 import { installHook, pendingCommitMessage, REFUSED } from './hook.js';
-import { pushRefusal } from './push-guard.js';
+import { gateRefusal, pushRefusal, UNGATED_ENV } from './push-guard.js';
 import { citedRefs, linkCommits } from './link.js';
 import { buildNews, loadEntries, newEntry, newsData, newsIssues, publicTitleTooLong, stampEntries } from './news.js';
 import { invalidResource, Plan, RafError, SCREENS, STATUSES, setPlanNotice } from './plan.js';
@@ -26,6 +26,7 @@ import { findProjects, readDepth, leadTour, readLeadUx, tourFreeLine, tourLine,
 import { configuredCap, expiredHoldLines, slotsLine, orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
 import { addHold, releaseHold } from './orchestrate/registry.js';
 import { activeLock, REPO_LOCK } from './orchestrate/lock.js';
+import { INTEGRATION_LOCK } from './orchestrate/integrate.js';
 import { cadenceHome, liveWaves, openLotsIn, openWavesIn, waveLotsIn } from './orchestrate/registry.js';
 import { blockingLots, LABEL, resumeCommand } from './orchestrate/table.js';
 import { classifyAll, measure, ollamaClassifier, readCache, readJournals, readRuns, renderReport, sampleKeys, serializeCache } from './corrections.js';
@@ -86,7 +87,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   cadence ref corpus <dossier> [--sans-rendu]   écrit le corpus synthétique à vérité connue (7 pièges : texte ambigu levé par une figure, figure qui contredit, table en image, gabarit BUFR, contrôle translucide, page Proposal, scan bruité) : par cas document.html et attendu.json, puis document.pdf et page-<n>.png (1700×2200) rendus par Playwright (CADENCE_PLAYWRIGHT = dossier du paquet) ; dossier existant ou Playwright introuvable : code 2
   cadence release patch|minor|major [--dry-run]   prépare le commit de version (package.json, package-lock.json, plugin.json, marketplace.json, CHANGELOG.md) sans commiter ni publier ; imprime les étapes du lead et vérifie docs/whats-new.md : refus sur un arbre sale, un [Unreleased] vide ou une version déjà taguée
   cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
-  cadence verify --gate --sha rév [--project dossier]   porte du projet (orchestrate.build puis orchestrate.test) : reprend le verdict enregistré par la vague quand son sha est le même et son arbre identique, sans rien rejouer (la sortie dit « verdict repris de la porte de la vague ») ; sinon la rejoue (« verdict rejoué : raison ») au sha dans l'arbre principal s'il est propre au sha, sinon dans un worktree jetable aux dépendances copiées (orchestrate.worktreeDeps), puis le retire : 0 vert, 1 rouge avec les tests en échec, 2 rien à rejouer
+  cadence verify --gate --sha rév [--project dossier]   porte du projet (orchestrate.build puis orchestrate.test) : reprend le verdict enregistré par la vague quand son sha est le même et son arbre identique, sans rien rejouer (la sortie dit « verdict repris de la porte de la vague ») ; sinon la rejoue (« verdict rejoué : raison ») au sha dans l'arbre principal s'il est propre au sha, sinon dans un worktree jetable aux dépendances copiées (orchestrate.worktreeDeps), puis le retire : 0 vert, 1 rouge avec les tests en échec, 2 rien à rejouer ; le verdict (0 ou 1) est noté par sha et le hook pre-push refuse un push dont le sha n'a pas de verdict vert (CADENCE_PUSH_UNGATED=1 passe outre)
   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 ».
@@ -414,6 +415,7 @@ function dispatch(argv, io) {
             }
             plan.save();
             io.out(id);
+            warnIntegrating(root, io.err);
             return 0;
         }
         case 'start':
@@ -455,6 +457,8 @@ function dispatch(argv, io) {
                 plan.note(rest[0], `abandonné : ${values.reason}`, today);
             plan.save();
             io.out(`${rest[0]} → ${status}`);
+            if (status === 'done')
+                warnIntegrating(root, io.err);
             if (status === 'done' && !rest[0].includes('/')) {
                 const lot = plan.lot(rest[0]);
                 if (lot.visible && !loadEntries(newsDir).some((e) => e.lots.includes(lot.id))) {
@@ -509,6 +513,7 @@ function dispatch(argv, io) {
             const plan = loadPlan();
             plan.note(rest[0], rest.slice(1).join(' '), today);
             plan.save();
+            warnIntegrating(root, io.err);
             return 0;
         }
         case 'did': {
@@ -742,7 +747,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]);
+                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': {
@@ -1123,15 +1128,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`). Sans vague qui tient le dépôt, ou avec un état de vague illisible
- * (avertissement), un hook ne gêne jamais un push.
+ * 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) ; 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) {
-    const holding = waveHolding(root);
-    if (!holding)
-        return 0;
+function prePush(root, io, remoteName, configPath, planFile) {
     let input = '';
     try {
         input = io.stdin ? io.stdin() : readFileSync(0, 'utf8');
@@ -1139,17 +1146,51 @@ function prePush(root, io, remoteName) {
     catch {
         return 0;
     }
-    const lots = waveLotsIn(cadenceHome(), holding.pid, root);
-    if (lots === null) {
-        io.err(`raf: vague ${holding.wave} : état illisible, push non vérifié`);
+    const holding = waveHolding(root);
+    if (holding) {
+        const lots = waveLotsIn(cadenceHome(), holding.pid, root);
+        if (lots === null) {
+            io.err(`raf: vague ${holding.wave} : état illisible, push non vérifié`);
+        }
+        else {
+            const refusal = pushRefusal(root, holding.wave, lots, input, remoteName || undefined);
+            if (refusal) {
+                io.err(`raf: ${refusal}`);
+                return REFUSED;
+            }
+        }
+    }
+    // La porte du projet (L426) : une config illisible ne gêne pas un push, comme un état de vague illisible.
+    let gate = false;
+    try {
+        const config = readOrchestrateConfig(configPath);
+        gate = Boolean(config.test || config.build);
+    }
+    catch {
         return 0;
     }
-    const refusal = pushRefusal(root, holding.wave, lots, input, remoteName || undefined);
-    if (refusal) {
-        io.err(`raf: ${refusal}`);
-        return REFUSED;
+    const refusal = gateRefusal(root, gate, input, planFile);
+    if (!refusal)
+        return 0;
+    if (io.env[UNGATED_ENV] === '1') {
+        io.err(`raf: ${refusal.replace(/^push refusé/, 'push passé outre')} — ${UNGATED_ENV}=1 est posée`);
+        return 0;
     }
-    return 0;
+    io.err(`raf: ${refusal}`);
+    return REFUSED;
+}
+/**
+ * Avertit (stderr, sans refuser) quand une intégration du dépôt est en cours (L425) : le plan écrit dans l'arbre principal est un fichier suivi modifié, et
+ * l'intégration en cours le voit et refuse son lot (« arbre du dépôt modifié »). Seul l'arbre principal est concerné : dans le worktree d'un lot, l'écriture
+ * ne change pas l'arbre que l'intégration contrôle.
+ */
+function warnIntegrating(root, err) {
+    const top = gitRoot(root);
+    if (!top || !statSync(join(top, '.git')).isDirectory())
+        return;
+    const holder = activeLock(join(sharedStateDir(root), INTEGRATION_LOCK));
+    if (holder)
+        err(`avertissement : intégration en cours (vague ${holder.wave}, pid ${holder.pid}) — ce plan est un fichier suivi modifié de l'arbre principal, l'intégration en cours peut refuser son lot (arbre du dépôt modifié) : committer le plan sans attendre`);
 }
 /** La vague qui tient le verrou du dépôt tant qu'un de ses lots y travaille encore (état illisible : on la tient pour active) ; null si le dépôt est libre. Partagé par `deliver` et `spec reseal`. */
 function waveHolding(root) {
@@ -1566,7 +1607,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)], 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/gate-verdict.js

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { sharedStateDir } from './state.js';
+const FILE = 'gate-verdicts.json';
+/** Verdicts gardés : les plus récents ; un push ne porte que des shas récents. */
+const KEEP = 200;
+const file = (repo) => join(sharedStateDir(repo), FILE);
+/** Tout le fichier ; absent ou illisible (écriture coupée, édition à la main), il vaut « aucun verdict ». */
+function readAll(repo) {
+    const path = file(repo);
+    if (!existsSync(path))
+        return {};
+    try {
+        const raw = JSON.parse(readFileSync(path, 'utf8'));
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+            return {};
+        const all = {};
+        for (const [sha, v] of Object.entries(raw)) {
+            const { code, at } = v;
+            if ((code === 0 || code === 1) && typeof at === 'string')
+                all[sha] = { code, at };
+        }
+        return all;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Note le verdict de `cadence verify --gate` pour `sha` (L426), dans l'état partagé du dépôt (`.git/cadence/gate-verdicts.json`, commun à tous les worktrees).
+ * Le dernier verdict d'un sha remplace le précédent ; au-delà de `KEEP` shas, les plus anciens partent. Écriture atomique (fichier voisin renommé).
+ */
+export function recordVerdict(repo, sha, code, at) {
+    const all = readAll(repo);
+    delete all[sha]; // réinséré en dernier : l'ordre des clés est celui des écritures
+    all[sha] = { code, at: at.toISOString() };
+    const kept = Object.fromEntries(Object.entries(all).slice(-KEEP));
+    const path = file(repo);
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(kept, null, 2)}\n`);
+    renameSync(tmp, path);
+}
+/** Le dernier verdict noté pour `sha` ; null si la porte n'a jamais rendu de verdict pour ce sha. */
+export function verdictFor(repo, sha) {
+    return readAll(repo)[sha] ?? null;
+}

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;