@sylad/cadence 1.24.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.24.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.24.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

@@ -747,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], 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 +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`). 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 +1169,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 +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)], 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;