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

package/README.md

@@ -7,7 +7,7 @@ cadence keeps both in plain files next to the code, and [Claude Code](https://cl
 
 ## Start
 
-Needs Node 22.18 or later (see [docs/stabilite.md](docs/stabilite.md)).
+Needs Node 22.18 or later (see [docs/stabilite.md](docs/stabilite.md)); waves also need Claude Code installed and logged in.
 
 ```sh
 npm install -g @sylad/cadence
@@ -16,6 +16,7 @@ raf add "My first lot" --estimate 1
 ```
 
 Then `raf start L1`, commit with `feat(L1): …`, `raf now` to see where you are, `raf done L1` when it is finished.
+`raf -v` prints the installed version. Every command is in [docs/raf.md](docs/raf.md).
 
 ## Lead several projects in 10 minutes
 
@@ -28,6 +29,12 @@ Something broken or missing? [Open an issue](https://github.com/Sylad/cadence/is
   <img alt="A lot goes through spec, mockup, accept, implement, review, ux and deliver; the lead picks the lots, answers the questions, re-verifies and delivers" src="docs/cycle-vague-light.svg">
 </picture>
 
+## With the tools you already have
+
+Linear, a `HANDOFF.md`, ADRs, Conventional Commits? Keep them: cadence replaces none, and each part is optional.
+It can read a plan your tracker keeps (read-only) and write its plan commits in your format.
+[docs/with-your-tools.md](docs/with-your-tools.md): what stays, what is optional, what plugs in.
+
 ## Install as a Claude Code plugin
 
 ```

package/bin/cadence.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { readFileSync } from 'node:fs';
 import { run } from '../dist/cli.js';
 
 const [tool, ...args] = process.argv.slice(2);
@@ -16,8 +15,7 @@ if (tool === 'raf') {
 } else if (['news', 'session', 'deliver', 'verify', 'skills', 'orchestrate', 'lead', 'corrections', 'perf', 'spec', 'ref', 'config', 'release'].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'));
-  console.log(pkg.version);
+  process.exitCode = await run([tool], io);
 } else {
   console.log(`cadence — une méthode de travail qui vit dans le dépôt
 

package/dist/audit.js

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
 import { check } from './check.js';
 import { parse } from 'yaml';
-import { changedFiles, fileAt, readCommits } from './git.js';
+import { changedFiles, fileAt, preloadChangedFiles, readCommits } from './git.js';
 import { citedRefs, linkCommits, scopeOf } from './link.js';
 import { PLAN_DEFAULT, PLAN_LEGACY, readDocsConfig, readNewsConfig, readOrchestrateConfig } from './config.js';
 import { ficheHypotheses } from './spec.js';
@@ -25,6 +25,7 @@ export function ownFiles(plan, root) {
     if (relative(root, plan.path) === PLAN_DEFAULT) {
         own.add(PLAN_LEGACY);
         own.add(join(dirname(PLAN_LEGACY), 'gantt.html'));
+        own.add(join(dirname(PLAN_DEFAULT), 'notes/.gitkeep')); // ce que `raf init` pose avec le plan (L377)
     }
     return own;
 }
@@ -45,6 +46,29 @@ function onlyPlanKeyChanged(root, sha, file) {
     const after = withoutPlanKey(fileAt(root, sha, file));
     return before !== null && before === after;
 }
+/** Les lignes que `raf init` ajoute à .gitignore (L377) ; le fichier est un fichier du plan quand un commit n'y ajoute que celles-là. */
+const INIT_GITIGNORE = ['.playwright-mcp/'];
+function gitignoreLines(text) {
+    return (text ?? '').split('\n').map((l) => l.trim()).filter(Boolean);
+}
+/** Le commit ne change de .gitignore que les lignes de `raf init` ? Rien n'est retiré, aucune autre ligne n'est ajoutée. */
+function onlyInitGitignore(root, sha, file) {
+    const before = gitignoreLines(fileAt(root, `${sha}^`, file));
+    const added = gitignoreLines(fileAt(root, sha, file));
+    const kept = added.filter((l) => !INIT_GITIGNORE.includes(l) || before.includes(l));
+    return before.every((l) => added.includes(l)) && kept.length === before.length;
+}
+/** Les clés d'un cadence.yaml qui naît dans le commit d'init : le plan et la porte de tests de la vague ; deliver:, session:… sont du travail. */
+const INIT_CONFIG_KEYS = ['plan', 'orchestrate'];
+function onlyInitKeys(text) {
+    try {
+        const doc = parse(text ?? '');
+        return doc !== null && typeof doc === 'object' && !Array.isArray(doc) && Object.keys(doc).every((k) => INIT_CONFIG_KEYS.includes(k));
+    }
+    catch {
+        return false;
+    }
+}
 /** 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 = {}) {
     const { patterns } = plan.ignore;
@@ -54,14 +78,17 @@ export function planCommits(plan, root, opts = {}) {
 /**
  * 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 —, les attendus QA 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,
+ * clé `plan:` est la seule à changer, ou qu'elle naît dans le commit avec les seules clés `plan:` et `orchestrate:` : deliver/session/… modifiés sont du travail ; et, de ce que `raf init` écrit, .cadence/notes/.gitkeep
+ * et les lignes qu'il ajoute à .gitignore, pour que le commit qui suit `raf init` n'ouvre pas d'écart, L377). 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) && (f !== config || onlyPlanKeyChanged(root, sha, f)));
+    const created = (f) => fileAt(root, `${sha}^`, f) === null && onlyInitKeys(fileAt(root, sha, f)); // cadence.yaml naît avec le plan : `raf init` puis la porte de tests, un seul commit (L377)
+    const initScaffold = (f) => f === '.gitignore' && onlyInitGitignore(root, sha, f);
+    return files.length > 0 && files.every((f) => initScaffold(f) || (own.has(f) && (f !== config || created(f) || onlyPlanKeyChanged(root, sha, f))));
 }
 /** Fichiers d'une version : manifestes JSON (dont seul le champ `version` bouge) et CHANGELOG. */
 const VERSION_JSON = /(^|\/)(package\.json|package-lock\.json|\.claude-plugin\/(plugin|marketplace)\.json)$/;
@@ -213,6 +240,16 @@ function workCommits(plan, root, commits) {
 export function lotCommits(plan, root, lotId) {
     return linkCommits(plan.lots(), planCommits(plan, root), plan.refs).byLot.get(lotId) ?? [];
 }
+/**
+ * Commits de travail des lots d'un rapprochement déjà fait (cf. lotWork) : le compte que montrent `raf now`, le tour et `session start`.
+ * `ids` : les seuls lots dont l'écran affiche un compte — chaque commit filtré coûte des `git diff-tree`, inutiles pour les autres.
+ */
+export function workByLot(plan, root, linked, ids) {
+    const wanted = ids ? new Set(ids) : null;
+    const shown = [...linked.byLot].filter(([id]) => !wanted || wanted.has(id));
+    preloadChangedFiles(root, shown.flatMap(([, commits]) => commits.map((c) => c.sha)));
+    return new Map(shown.map(([id, commits]) => [id, workCommits(plan, root, commits)]));
+}
 /** Commits à relire d'un lot, du plus récent au plus ancien — ce que compte la porte de revue de code et que liste `raf commits`. */
 export function lotWork(plan, root, lotId) {
     return workCommits(plan, root, lotCommits(plan, root, lotId));

package/dist/cli.js

@@ -4,7 +4,7 @@ import { basename, dirname, join, posix, relative, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
 import { defaultPlan, PLAN_DEFAULT, PLAN_LEGACY, readDocsConfig, readHookConfig, readNewsConfig, readOrchestrateConfig, readPerfConfig, readPlanConfig, readSessionConfig } from './config.js';
 import { repoSections, repoShas, resolveLotRepos } from './repos.js';
-import { audit, exemptPlanOnly, gateProgress, gateText, gateWaiting, hypothesesOf, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
+import { audit, exemptPlanOnly, gateProgress, gateText, gateWaiting, hypothesesOf, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork, workByLot } from './audit.js';
 import { short } from './check.js';
 import { isDay, toDay } from './dates.js';
 import { deliver, parseDeliverConfig, realDeps, shellQuote } from './deliver.js';
@@ -62,7 +62,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf list [--status todo|doing|done|dropped]
   raf check [--since date] [--idle 7]   (défaut : date « since » du plan) code 1 s'il y a des écarts
   raf ignore <sha> | "<sujet exact>" [--reason texte]   acquitte un commit sans lot, citant un id inconnu ou des lots sans y travailler, sans réécrire l'historique ; raf check --ignored les liste
-  raf docs-ok <lot> --reason texte   acquitte l'écart docs.sync d'un lot (documentation en retard) avec la raison pour laquelle la documentation reste telle quelle ; lu par raf check et par orchestrate, qui ne rend jamais prêt un lot avec un écart ouvert
+  raf docs-ok <lot> --reason texte   acquitte l'écart docs.sync d'un lot (documentation en retard) avec la raison pour laquelle la documentation reste telle quelle (plan en lecture seule : .cadence/docs-ok.yaml, le plan n'est pas touché) ; lu par raf check et par orchestrate, qui ne rend jamais prêt un lot avec un écart ouvert
   raf gantt [-o .cadence/gantt.html]
   cadence config set <clé> <valeur> --all [--dry-run] [--depth n]   pose la même clé dans le cadence.yaml de chaque projet du dossier (ceux de lead tour), commentaires et ordre gardés, un lot de config qui la cite (raf add + start) et un commit à chemin explicite par projet ; ne pousse pas ; liste ce qui est fait et sauté (dépôt sale, déjà posée, plan en lecture seule) ; s'arrête sur une config qui ne se relit pas
   raf migrate [--dry-run]   déplace docs/plan/raf.yaml vers .cadence/raf.yaml (git mv) et réécrit les lecteurs du chemin dans le dépôt ; --dry-run les liste sans rien toucher ; refus tant qu'un lecteur n'est pas traité (migrate.keep de cadence.yaml pour ceux qui ne lisent pas le plan) ; rejouable
@@ -117,9 +117,18 @@ function legacyPlanLine(root, legacy) {
         return `raf: ${PLAN_LEGACY} est ignoré : ${PLAN_DEFAULT} existe aussi et fait foi (supprimer ou fusionner l'ancien)`;
     return `raf: ${PLAN_LEGACY} est l'ancien emplacement du plan ; le déplacer : cd ${shellQuote(root)} && mkdir -p ${dirname(PLAN_DEFAULT)} && ${gitRoot(root) && isTracked(root, PLAN_LEGACY) ? 'git mv' : 'mv'} ${PLAN_LEGACY} ${PLAN_DEFAULT}`;
 }
+/** La version du paquet (`package.json` est à côté de `src/` comme de `dist/`). */
+function packageVersion() {
+    return JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+}
 export function run(argv, io) {
     setPlanNotice(io.err);
     try {
+        // Comme `cadence --version` (L376) : en premier argument seulement, ailleurs c'est une option comme une autre.
+        if (argv[0] === '--version' || argv[0] === '-v') {
+            io.out(packageVersion());
+            return 0;
+        }
         // orchestrate a ses propres options (--status et --resume prennent une valeur facultative, --answer en prend deux).
         if (argv[0] === 'orchestrate') {
             return orchestrate(argv.slice(1), io, realOrchestrateDeps(io.env)).catch((e) => failure(e, io));
@@ -633,8 +642,13 @@ function dispatch(argv, io) {
             const plan = loadPlan();
             knownLot(plan, rest[0], 'docs-ok se pose sur un lot, pas sur une sous-tâche');
             plan.setDocsOk(rest[0], values.reason ?? '', today);
-            plan.save();
-            io.out(`${rest[0]} : écart docs.sync acquitté`);
+            // Un plan en lecture seule n'est pas écrit : l'acquittement est dans .cadence/docs-ok.yaml, à commiter à la place du plan (L386).
+            if (plan.readonly)
+                io.out(`${rest[0]} : écart docs.sync acquitté dans .cadence/docs-ok.yaml (le plan n'est pas touché) — commiter ce fichier`);
+            else {
+                plan.save();
+                io.out(`${rest[0]} : écart docs.sync acquitté`);
+            }
             return 0;
         }
         case 'check': {
@@ -663,7 +677,7 @@ function dispatch(argv, io) {
             const lots = plan.lots();
             const linked = linkCommits(lots, planCommits(plan, root), plan.refs);
             const stamp = io.now();
-            const html = renderGantt(ganttData(plan.project, schedule(lots, linked.byLot, today), today, `${toDay(stamp)} ${stamp.toTimeString().slice(0, 5)}`));
+            const html = renderGantt(ganttData(plan.project, schedule(lots, workByLot(plan, root, linked), today), today, `${toDay(stamp)} ${stamp.toTimeString().slice(0, 5)}`));
             const out = resolve(io.cwd, values.output ?? join(dirname(planPath), 'gantt.html'));
             mkdirSync(dirname(out), { recursive: true });
             writeFileSync(out, html);
@@ -841,8 +855,9 @@ function describe(l, commits) {
 function now(plan, root, newsDir, today, io) {
     const lots = plan.lots();
     const linked = linkCommits(lots, planCommits(plan, root), plan.refs);
-    const count = (id) => linked.byLot.get(id)?.length ?? 0;
     const { doing, ready, blocked } = nextUp(lots);
+    const work = workByLot(plan, root, linked, [...doing, ...ready.slice(0, 5)].map((l) => l.id));
+    const count = (id) => work.get(id)?.length ?? 0;
     io.out(`${plan.project} — ${today}`);
     io.out('\nEn cours');
     if (doing.length === 0)

package/dist/git.js

@@ -1,5 +1,5 @@
 import { execFileSync } from 'node:child_process';
-import { rmSync } from 'node:fs';
+import { 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.
@@ -99,9 +99,37 @@ export function syncIndexWithHead(cwd, file) {
  * le commit supprime (`--diff-filter=d`) : un fichier supprimé n'est plus du code à tester.
  */
 export function changedFiles(cwd, sha, opts = {}) {
+    const known = opts.withoutDeleted ? undefined : filesCache.get(`${cwd}\0${sha}`);
+    if (known)
+        return known;
     // -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', ...(opts.withoutDeleted ? ['--diff-filter=d'] : []), sha]).split('\0').filter(Boolean);
 }
+/** Fichiers modifiés par commit (hors suppressions écartées), par dépôt : un sha ne change jamais de contenu. */
+const filesCache = new Map();
+/**
+ * Lit d'un seul appel git les fichiers modifiés de ces commits, pour que `changedFiles` ne lance pas un `git diff-tree` par commit
+ * (L381 : filtrer les milliers de commits liés du gantt coûtait ~20 s). Même résultat que `changedFiles` ; un commit de fusion n'a
+ * aucun fichier, comme avec `diff-tree`. Sans effet sur un dépôt illisible : `changedFiles` retombe sur `git diff-tree`.
+ */
+export function preloadChangedFiles(cwd, shas) {
+    const missing = shas.filter((sha) => !filesCache.has(`${cwd}\0${sha}`));
+    if (missing.length < 2)
+        return;
+    let out;
+    try {
+        out = execFileSync('git', ['-c', 'core.quotepath=off', 'log', '--no-walk=unsorted', '--stdin', '--root', '--format=%x01%H', '--name-only', '-z'], {
+            cwd, encoding: 'utf8', input: missing.join('\n') + '\n', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: 1024 * 1024 * 1024,
+        });
+    }
+    catch {
+        return;
+    }
+    for (const block of out.split('\x01').slice(1)) {
+        const [sha, ...files] = block.split('\0');
+        filesCache.set(`${cwd}\0${sha}`, files.map((f) => f.replace(/^\n/, '')).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 {
@@ -240,6 +268,27 @@ export function restorePaths(root, paths) {
             rmSync(resolve(root, f), { force: true });
     }
 }
+/**
+ * Remet `paths` comme à HEAD dans l'arbre de travail seulement, sans toucher à l'index : possible quand un `index.lock` bloque
+ * tout ce qui l'écrit (`restorePaths`, `git checkout`). Un fichier que HEAD ne connaît pas est supprimé.
+ */
+export function restoreWorktree(root, paths) {
+    for (const f of paths) {
+        let text;
+        try {
+            text = execFileSync('git', ['show', `HEAD:${f}`], { cwd: root, stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 1024 * 1024 * 1024 });
+        }
+        catch {
+            rmSync(resolve(root, f), { force: true });
+            continue;
+        }
+        writeFileSync(resolve(root, f), text);
+    }
+}
+/** Chemin du verrou de l'index de `repo` (`<git-dir>/index.lock`, celui du worktree s'il en est un). */
+export function indexLockPath(repo) {
+    return resolve(repo, git(repo, ['rev-parse', '--git-path', 'index.lock']).trim());
+}
 /** Un fichier SUIVI est-il modifié (indexé ou non) ? Les fichiers non suivis ne comptent pas : un commit à chemins explicites ne les embarque pas. `except` : chemins qu'on ne compte pas. */
 export function hasTrackedChanges(cwd, except = []) {
     return git(cwd, ['status', '--porcelain', '--untracked-files=no', '--', '.', ...except.map((f) => `:(exclude)${f}`)]).trim() !== '';

package/dist/lead.js

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { basename, join, relative, sep } from 'node:path';
-import { audit, gateWaiting, nextUp, planCommits } from './audit.js';
+import { audit, gateWaiting, nextUp, planCommits, workByLot } from './audit.js';
 import { PLAN_DEFAULT, PLAN_LEGACY, planLoader, readPlanConfig } from './config.js';
 import { diffDays } from './dates.js';
 import { gitRoot, repoStatus } from './git.js';
@@ -114,13 +114,14 @@ export function tourRow(dir, today, idle = TOUR_IDLE, name = basename(dir)) {
         const lots = plan.lots();
         const all = linkCommits(lots, planCommits(plan, root), plan.refs);
         const { doing, ready, blocked } = nextUp(lots);
+        const work = workByLot(plan, root, all, doing.map((l) => l.id));
         row.doing = doing.map((l) => {
-            const commits = all.byLot.get(l.id) ?? [];
-            const last = lastActivity(l, commits);
+            const count = work.get(l.id)?.length ?? 0;
+            const last = lastActivity(l, all.byLot.get(l.id) ?? []);
             if (!last)
-                return { id: l.id, commits: commits.length, noActivity: true };
+                return { id: l.id, commits: count, noActivity: true };
             const days = diffDays(last, today);
-            return days > idle ? { id: l.id, commits: commits.length, silentDays: days } : { id: l.id, commits: commits.length };
+            return days > idle ? { id: l.id, commits: count, silentDays: days } : { id: l.id, commits: count };
         });
         row.drift = audit(plan, root, join(root, 'docs/nouveautes'), today).map((i) => `${i.warning ? '⚠' : '✗'} ${i.message}`);
         row.notes = readNext(stateDir(root))?.lines ?? [];

package/dist/orchestrate/changelog-merge.js

@@ -12,8 +12,13 @@ function split(text) {
         end = lines.length;
     return { head: lines.slice(0, at + 1).join('\n'), block: lines.slice(at + 1, end), tail: lines.slice(end).join('\n') };
 }
-/** Sections du bloc `[Unreleased]` : une entrée est une ligne `- ` et ses lignes de suite. Deux titres identiques sont fondus. Du texte hors entrée : null. */
-function sections(block) {
+/** Clé des entrées nues (avant tout `### `) quand `sections` les accepte ; aucun titre réel n'est vide. */
+const BARE = '';
+/**
+ * Sections du bloc `[Unreleased]` : une entrée est une ligne `- ` et ses lignes de suite. Deux titres identiques sont fondus. Du texte hors entrée : null.
+ * Une entrée avant tout titre est refusée (null), sauf avec `allowBare` : elle est alors rangée sous la clé `BARE`.
+ */
+function sections(block, allowBare = false) {
     const out = new Map();
     let current = null;
     for (const line of block) {
@@ -24,6 +29,11 @@ function sections(block) {
             current = out.get(title) ?? [];
             out.set(title, current);
         }
+        else if (!current && allowBare && line.startsWith('- ')) {
+            current = out.get(BARE) ?? [];
+            out.set(BARE, current);
+            current.push(line);
+        }
         else if (!current) {
             return null;
         }
@@ -39,6 +49,27 @@ function sections(block) {
     }
     return out;
 }
+/**
+ * Range les entrées nues des trois côtés sous une rubrique (L383) : celle que les côtés ont ajoutée à la base si elle est seule, sinon la seule rubrique qu'ils
+ * portent. Aucune rubrique, ou plusieurs candidates : le choix serait le nôtre, on rend false et le conflit reste à la main.
+ */
+function fileBare(base, ours, theirs) {
+    if (![base, ours, theirs].some((s) => s.has(BARE)))
+        return true;
+    const titles = [...new Set([...ours.keys(), ...theirs.keys()])].filter((t) => t !== BARE);
+    const added = titles.filter((t) => !base.has(t));
+    const target = added.length === 1 ? added[0] : titles.length === 1 ? titles[0] : null;
+    if (target === null)
+        return false;
+    for (const side of [base, ours, theirs]) {
+        const bare = side.get(BARE);
+        if (!bare)
+            continue;
+        side.delete(BARE);
+        side.set(target, [...(side.get(target) ?? []), ...bare]);
+    }
+    return true;
+}
 /** `base` est une sous-suite de `side` : rien n'a été retiré ni modifié, seul de l'ajout s'y est glissé. */
 function onlyAdds(base, side) {
     let i = 0;
@@ -63,7 +94,8 @@ function pick(base, ours, theirs) {
  * Fusion à trois du CHANGELOG quand deux lots y ont chacun ajouté une entrée sous `[Unreleased]` (L314) : union par section, un seul titre par section,
  * sections dans l'ordre de Keep a Changelog, les entrées de `ours` puis celles de `theirs` qui n'y sont pas déjà. Le reste du fichier suit le côté qui l'a
  * changé. Rend null quand ce n'est pas de l'ajout pur — une entrée de base retirée ou modifiée, du texte libre sous `[Unreleased]`, le reste du fichier
- * changé des deux côtés, pas de section `[Unreleased]` — : le conflit reste alors à la main.
+ * changé des deux côtés, pas de section `[Unreleased]` — : le conflit reste alors à la main. Une entrée nue (sans rubrique) d'un côté est rangée sous la
+ * rubrique que l'autre a ajoutée (L383) ; sans rubrique unique où la ranger, le conflit reste à la main.
  *
  * `start` est le CHANGELOG du point de départ de la branche rejouée (L323). Une entrée de `base` qui n'y était pas a été ajoutée par un commit précédent du
  * lot lui-même : `theirs` peut la modifier ou la retirer, sa version gagne (l'ancienne est écartée de `ours`). Sans `start`, aucune entrée n'est au lot.
@@ -74,11 +106,11 @@ export function mergeUnreleased(base, ours, theirs, start) {
         return null;
     const head = pick(b.head, o.head, t.head);
     const tail = pick(b.tail, o.tail, t.tail);
-    const [bs, os, ts] = [sections(b.block), sections(o.block), sections(t.block)];
-    if (head === null || tail === null || !bs || !os || !ts)
+    const [bs, os, ts] = [sections(b.block, true), sections(o.block, true), sections(t.block, true)];
+    if (head === null || tail === null || !bs || !os || !ts || !fileBare(bs, os, ts))
         return null;
     const st = start === undefined ? null : split(start);
-    const startEntries = new Set([...(st ? (sections(st.block)?.values() ?? []) : [])].flat());
+    const startEntries = new Set([...(st ? (sections(st.block, true)?.values() ?? []) : [])].flat());
     const own = new Set(start === undefined || !st ? [] : [...bs.values()].flat().filter((e) => !startEntries.has(e)));
     // Une entrée de base que ours range sous une version publiée (la branche a été publiée pendant la vie du lot) n'a pas été retirée : elle a changé de place.
     // Seule une entrée de base compte, entière : une entrée nouvelle de theirs qui est un bout d'une entrée publiée n'est pas la même, elle reste au lot.

package/dist/orchestrate/command.js

@@ -27,7 +27,7 @@ import { costlyHypotheses, specScreen, specText } from './spec.js';
 import { fichesDuDossier } from '../spec.js';
 import { candidates, parsePriority, parseUntil, readPriority, stopReason } from './continue.js';
 import { precheckNothingToFind, Budget, ESCALATION_RESERVE, DROPPED, STOP_REQUESTED, MAX_PASSES, REVIEW_RESERVE, budgetStep, heldForEscalation, lotSpent, MAX_PASSES_CONVERGING, briefName, countInterrupted, planNoteHandBack, leadReviewedHandBack, HYPOTHESES_HANDBACK, handBackDroppedQuestions, needsPrecheck, workDir } from './cycle.js';
-import { canInstallPrePush, installPrePush, removePrePush, snapshot } from './guard.js';
+import { canInstallPrePush, gitProcessRunning, indexLockRefusal, installPrePush, longDuration, removePrePush, snapshot } from './guard.js';
 import { buildArgs, buildLocalArgs, killSessions, MODEL_ALIASES, mcpServersFor, readAgents, realClaude } from './launch.js';
 import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
 import { groupLots, runPool } from './pool.js';
@@ -239,7 +239,7 @@ function resolveTargets(args, io, refusals) {
         }
         seen.add(key);
         if (!existsSync(projectDir) || !statSync(projectDir).isDirectory()) {
-            refusals.push(`${key} : ${l.project ? `dossier ${projectDir} introuvable` : 'dossier courant illisible'}`);
+            refusals.push(`${key} : ${l.project ? `dossier ${projectDir} introuvable (le projet est un sous-dossier du dossier courant ; dans un dépôt, \`.:${l.lot}\`)` : 'dossier courant illisible'}`);
             continue;
         }
         if (!isProject(projectDir)) {
@@ -266,6 +266,10 @@ function olderThanEffort(version) {
     const [a, b, c] = [Number(m[1]), Number(m[2]), Number(m[3])];
     return a < 2 || (a === 2 && (b < 1 || (b === 1 && c < 284)));
 }
+/** L378 : claude installé mais non connecté échoue à la première session, après le démarrage du lot dans le plan. Null si connecté ou état illisible. */
+function notLoggedIn(deps) {
+    return deps.claudeAuth?.()?.loggedIn === false ? "claude n'est pas connecté : lancer `claude` puis /login (état : `claude auth status`)" : null;
+}
 /** Préconditions : tout ce qui peut être refusé l'est ici, avant d'agir, sans verrou ni écriture. */
 async function preflight(args, targets, io, deps, launch, opts = {}) {
     const refusals = [];
@@ -276,6 +280,9 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
         refusals.push('claude introuvable (CADENCE_CLAUDE_BIN, ou claude dans le PATH)');
     else if (!info.jsonSchema)
         refusals.push(`claude ${info.version} n'a pas --json-schema : mettre claude à jour`);
+    const login = info && !args.dryRun ? notLoggedIn(deps) : null; // la simulation n'ouvre pas de session : elle le signale (dryRun) sans refuser
+    if (login)
+        refusals.push(login);
     const lots = [];
     const repoChecked = new Set();
     const byProject = new Map();
@@ -337,6 +344,9 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
             const dirty = await trackedDirty(repo);
             if (dirty.length)
                 refusals.push(`${basename(repo)} : arbre sale, ${dirty.length} fichier(s) suivi(s) modifié(s) : ${dirty.join(', ')}`);
+            const locked = indexLockRefusal(repo, io.now(), deps.gitRunning ?? gitProcessRunning);
+            if (locked)
+                refusals.push(`${basename(repo)} : ${locked}`);
             const hook = canInstallPrePush(repo);
             if (hook)
                 refusals.push(`${basename(repo)} : ${hook}`);
@@ -459,6 +469,9 @@ function dryRun(lots, io, deps, budget, id) {
     const tmp = mkdtempSync(join(tmpdir(), 'cadence-orchestrate-'));
     const agents = agentsOf(deps);
     io.out(`vague ${id} — simulation, rien n'est lancé (budget ${budget} tokens comptés)`);
+    const login = notLoggedIn(deps);
+    if (login)
+        io.out(`⚠ ${login} — sans cela le vrai lancement est refusé`);
     const repos = [...new Set(lots.map((l) => l.repo))];
     const noTestSaid = new Set();
     const redSaid = new Set();
@@ -594,16 +607,6 @@ export function liveLines(cap = DEFAULT_MAX_SESSIONS, now = new Date()) {
         lines.push(`  ${w.wave} (pid ${w.pid}, depuis ${w.started}) lancée depuis ${w.cwd} · plafond ${w.cap ?? '?'} · dépôts : ${w.repos.join(', ')}`);
     return lines;
 }
-/** Durée à la minute : « 12 min », « 5 h 10 min », « 2 j 3 h ». */
-function longDuration(ms) {
-    const m = Math.max(0, Math.floor(ms / 60_000));
-    if (m < 60)
-        return `${m} min`;
-    const h = Math.floor(m / 60);
-    if (h < 24)
-        return `${h} h ${String(m % 60).padStart(2, '0')} min`;
-    return `${Math.floor(h / 24)} j ${h % 24} h`;
-}
 /** Une ligne ⚠ par session du lead dont le TTL est échu et qui n'a pas été rendue (L278) : vide sans session échue. */
 export function expiredHoldLines(now = new Date()) {
     return expiredHolds(cadenceHome(), now).map((h) => {
@@ -674,8 +677,17 @@ function removeWorktree(args, io) {
     io.out(`orchestrate : ${key} : worktree retiré (${gone.abandoned} commit(s) abandonné(s))`);
     return 0;
 }
+/** L382 : `claude auth status` peut durer jusqu'à 20 s ; en --continue, preflight() le relancerait pour chaque lot candidat de chaque tour. Une seule lecture par lancement (une vague). */
+function onceAuth(deps) {
+    const read = deps.claudeAuth;
+    if (!read)
+        return deps;
+    let cached;
+    return { ...deps, claudeAuth: () => (cached ??= { value: read() }).value };
+}
 /** Point d'entrée de `cadence orchestrate`. 0 prêts · 1 rendus au lead · 2 refus avant d'agir · 3 suspendue (budget, quota). */
 export async function orchestrate(argv, io, deps) {
+    deps = onceAuth(deps);
     const args = parseOrchestrateArgs(argv);
     const launch = io.cwd;
     const today = io.env.RAF_TODAY && isDay(io.env.RAF_TODAY) ? io.env.RAF_TODAY : toDay(io.now());
@@ -1612,6 +1624,16 @@ async function resume(args, argv, io, deps, launch, today) {
     }
     return continueRounds(await execute(wave, live, store, io, deps, today, maxSessions(args, io), lots), wave, lots, store, io, deps, today, args, launch);
 }
+/** `loggedIn` de la sortie JSON de `claude auth status` ; null si elle n'est pas lisible (versions sans cette commande : pas de refus). */
+export function parseAuthStatus(text) {
+    try {
+        const v = JSON.parse(text);
+        return typeof v.loggedIn === 'boolean' ? { loggedIn: v.loggedIn } : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Dépendances réelles : `claude` (ou CADENCE_CLAUDE_BIN), agents et gabarits du paquet, journaux de ~/.claude. */
 export function realOrchestrateDeps(env) {
     const bin = env.CADENCE_CLAUDE_BIN || 'claude';
@@ -1630,6 +1652,16 @@ export function realOrchestrateDeps(env) {
                 return null;
             }
         },
+        claudeAuth: () => {
+            try {
+                // `auth status` sort en 1 quand claude n'est pas connecté, et imprime quand même le JSON.
+                const text = execFileSync(bin, ['auth', 'status'], { env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 20_000 });
+                return parseAuthStatus(text);
+            }
+            catch (e) {
+                return parseAuthStatus(String(e.stdout ?? ''));
+            }
+        },
         agentsDir: AGENTS_DIR,
         snapshot: child ? undefined : { packageRoot: PACKAGE_ROOT, reexec: spawnReexec },
         claudeHome: env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'),

package/dist/orchestrate/cycle.js

@@ -10,14 +10,14 @@ import { readDocsConfig, readPlanConfig } from '../config.js';
 import { PLAN_ACTIONS, leadAnswerMessage, planCommitMessage } from '../plan-commit.js';
 import { articleRepoDir, articlesBrief, docSyncBrief, docSyncGaps, filesOf, gapMessage } from '../docsync.js';
 import { testGateMissing } from '../testgate.js';
-import { changedFiles, dirtyPaths, gitCommonDir, isAncestor, readCommits, resolveCommit, restorePaths } from '../git.js';
+import { changedFiles, dirtyPaths, gitCommonDir, isAncestor, readCommits, resolveCommit, restoreWorktree, tryGit } from '../git.js';
 import { blockingLots, gitCommitsIn } from './table.js';
 import { citedRefs } from '../link.js';
 import { repoShas, repoWork } from '../repos.js';
 import { isOpen, RafError } from '../plan.js';
 import { isPlanOnly } from '../audit.js';
-import { compareBaseline, failedTests, hasUnnamedFailure, jestTestFiles } from './baseline.js';
-import { replayFile, replayRanFile, shellArg, TEST_WORKERS_ENV, testWorkersText } from './workers.js';
+import { compareBaseline, failedTests, hasUnnamedFailure } from './baseline.js';
+import { replayRed, TEST_WORKERS_ENV, testWorkersText } from './workers.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
 import { capturesText, headline, integrationText, localReading, newsText, objective, renderBrief, reposText, shotsText, TEMPLATES_DIR, tmpText } from './briefs.js';
 import { SlotAbandoned } from './registry.js';
@@ -154,18 +154,18 @@ async function commitPlan(c, message, root = c.lot.repo, before = new Map()) {
     const foreign = dirty.filter((f) => !ownFile(f));
     if (foreign.length)
         return `arbre sale (fichiers hors plan) : ${foreign.join(', ')}`;
-    git(repo, 'add', '--', ...dirty);
     try {
+        git(repo, 'add', '--', ...dirty);
         git(repo, 'commit', '-q', '-m', message, '--', ...dirty);
     }
     catch (e) {
-        // Commit refusé (hook commit-msg…, L343) : le plan n'a pas à rester indexé ni modifié par cadence, le lot suivant y verrait un dépôt sale et serait rendu.
+        // Commit refusé (hook commit-msg…, L343) ou index verrouillé (L385) : le plan n'a pas à rester indexé ni modifié par cadence, le lot suivant y verrait un dépôt sale et serait rendu.
         // Ce que le lead avait modifié sans commiter (raf add, raf note pendant la session) est remis, pas effacé.
-        git(repo, 'restore', '--staged', '--', ...dirty);
+        // Un index.lock bloque aussi la désindexation et le checkout : le désindexage est tenté sans plus, et l'arbre de travail est remis sans passer par l'index.
+        tryGit(repo, ['restore', '--staged', '--', ...dirty]);
         const own = dirty.filter((f) => !before.has(f));
-        // restorePaths : un fichier de plan.onWrite (L346) pas encore au dépôt est retiré, `git restore --source=HEAD` échouerait sur lui (pathspec) et laisserait le plan modifié.
         if (own.length)
-            restorePaths(repo, own);
+            restoreWorktree(repo, own);
         for (const [f, text] of before) {
             if (!dirty.includes(f))
                 continue;
@@ -550,9 +550,11 @@ function briefFor(c, kind, local = false) {
             vars.constats = constatLines(l.constats);
             if (l.docsFix) {
                 vars.elsewhere = articlesBrief(l.repo, docsConfig(c).articles ?? []);
-                vars.ack = wd(c) === l.repo
-                    ? `run \`raf docs-ok ${l.lot} --reason "why the documentation stays true"\` (a reason is required), then commit the plan file alone (\`git add -- .cadence/raf.yaml\`, or the path of the plan; message \`chore(${l.lot}): docs-ok\`).`
-                    : `this is a worktree, where only the program writes the plan: do not run \`raf docs-ok\` and do not touch the plan file. Make no commit and say under "choix" why the documentation stays true: the lot is handed back to the lead, who acknowledges it in the main checkout (\`raf docs-ok ${l.lot} --reason "…"\`).`;
+                vars.ack = wd(c) === l.repo && histPlan(c).readonly
+                    ? `run \`raf docs-ok ${l.lot} --reason "why the documentation stays true"\` (a reason is required): the plan is kept by another tool and is not written, the acknowledgement goes to \`.cadence/docs-ok.yaml\`; then commit that file alone (\`git add -- .cadence/docs-ok.yaml\`; message \`chore(${l.lot}): docs-ok\`).`
+                    : wd(c) === l.repo
+                        ? `run \`raf docs-ok ${l.lot} --reason "why the documentation stays true"\` (a reason is required), then commit the plan file alone (\`git add -- .cadence/raf.yaml\`, or the path of the plan; message \`chore(${l.lot}): docs-ok\`).`
+                        : `this is a worktree, where only the program writes the plan: do not run \`raf docs-ok\` and do not touch the plan file. Make no commit and say under "choix" why the documentation stays true: the lot is handed back to the lead, who acknowledges it in the main checkout (\`raf docs-ok ${l.lot} --reason "…"\`).`;
             }
         }
         else if (interrupted) {
@@ -2016,32 +2018,12 @@ async function programChecks(c, red, runs) {
         return;
     }
 }
-/** Sortie d'un lanceur qui n'a trouvé aucun test à rejouer : la ligne de fin du lanceur (vitest « No test files found, exiting with code », jest « No tests found, exiting with code », pytest « no tests ran in »), en début de ligne — pas ces mots cités dans le titre ou la sortie d'un test. */
-const NO_TEST_RAN = /^\W*(?:no test files? found, exiting with code|no tests? found, exiting with code|no tests ran in)\b/im;
-/** Rejeux d'un test rouge de la porte, seul (L354) : rouge aux deux, il est compté. */
-const REPLAYS = 2;
 /**
  * Rejoue SEULS (la commande `orchestrate.testReplay` où `{files}` devient les fichiers de ces tests, dans `cwd` : le worktree du lot, ou celui de la ligne de base) les tests rouges d'une suite entière (L354). Le 26-10, vitest à 31 workers par suite sur une machine à 4 sessions rougissait des tests
- * qui passaient seuls : quatre corrections vides (4 à 11 min chacune). Un test vert à un rejeu est `unstable` ; rouge aux `REPLAYS` rejeux, ou sans fichier désignable (rien à rejouer seul), il reste dans `red`.
+ * qui passaient seuls : quatre corrections vides (4 à 11 min chacune). Un test vert à un rejeu est `unstable` ; rouge aux rejeux, ou sans fichier désignable (rien à rejouer seul), il reste dans `red`. Le rejeu lui-même est `replayRed` (workers.ts), partagé avec `verify --gate` (L387).
  */
-async function replayAlone(c, template, names, output, cwd = wd(c)) {
-    const jest = jestTestFiles(output);
-    const fileOf = (n) => replayFile(n) ?? jest.get(n) ?? null;
-    let red = names;
-    const unstable = [];
-    for (let i = 0; i < REPLAYS; i++) {
-        const replayable = red.filter((n) => fileOf(n));
-        const files = [...new Set(replayable.map((n) => fileOf(n)))];
-        if (!files.length)
-            break;
-        const r = await sh(c, template.replaceAll('{files}', () => files.map(shellArg).join(' ')), undefined, undefined, cwd);
-        // Seul un rejeu qui sort en 0 en ayant exécuté le FICHIER du test vaut vert. Un rejeu en échec ne conclut rien pour un test qu'il ne nomme pas : sur une porte composée (`a && b`) les fichiers n'atteignent que le dernier lanceur, un premier lanceur qui rougit coupe avant lui. Un rejeu sans test exécuté (filtre sans fichier, `passWithNoTests`) sort en 0 sans rien prouver, et un lanceur qui ignore sans rien dire un fichier qu'il ne trouve pas (vitest d'un autre espace de travail) sort en 0 sans l'avoir joué : le fichier doit figurer, chemin entier, sur une ligne du lanceur de la sortie du rejeu, hors écho de la commande par npm/pnpm/yarn (`replayRanFile`).
-        const ran = r.code === 0 && !NO_TEST_RAN.test(r.output);
-        const passed = ran ? replayable.filter((n) => replayRanFile(r.output, fileOf(n))) : [];
-        unstable.push(...passed);
-        red = red.filter((n) => !passed.includes(n));
-    }
-    return { red, unstable };
+function replayAlone(c, template, names, output, cwd = wd(c)) {
+    return replayRed((command) => sh(c, command, undefined, undefined, cwd), template, names, output);
 }
 /** Trace des tests instables sous charge (L354) : le lot (`instables`, journal et `cadence perf`), un avertissement du lot (tableau de fin de vague) et une ligne du journal de la vague. */
 function noteUnstable(c, tests) {