@sylad/cadence 0.20.0 → 0.22.0

package/dist/config.js

@@ -3,7 +3,7 @@ import { basename, dirname, isAbsolute, join, posix, relative, resolve } from 'n
 import { parse } from 'yaml';
 import { isDay } from './dates.js';
 import { gitRoot } from './git.js';
-import { FIELDS, RafError, STATUSES } from './plan.js';
+import { FIELDS, Plan, RafError, STATUSES } from './plan.js';
 const KEYS = ['path', 'project', 'since', 'ignore', 'files', 'lots', 'fields', 'statuses', 'estimates'];
 const FORMAT_KEYS = ['lots', 'fields', 'statuses', 'estimates'];
 const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
@@ -89,6 +89,16 @@ export function readPlanConfig(file, root) {
         throw bad('path est vide');
     return { ...(p.path != null ? { path: String(p.path) } : {}), settings };
 }
+/**
+ * Le chargeur du plan du projet dont `root` est la racine : le `cadence.yaml` est lu tout de suite (une erreur sort ici), le plan à
+ * chaque appel. Une seule lecture de « où est le plan et comment le lire » pour l'orchestrateur, `lead tour` et le tirage de `--continue`.
+ */
+export function planLoader(root) {
+    const configPath = join(root, 'cadence.yaml');
+    const planConfig = readPlanConfig(configPath, root);
+    const planPath = resolve(root, planConfig?.path ?? 'docs/plan/raf.yaml');
+    return () => Plan.load(planPath, { ...planConfig?.settings, config: configPath });
+}
 function parseFormat(p, bad) {
     const format = { lots: p.lots == null ? 'lots' : String(p.lots), fields: {}, statuses: {}, estimates: {} };
     for (const key of ['fields', 'statuses', 'estimates'])
@@ -209,12 +219,14 @@ export function readSessionConfig(file) {
     }
     return config;
 }
+const EFFORTS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
+export const EFFORT_STEPS = ['precheck', 'implement', 'fix', 'review', 'ux'];
 const MODELS = ['haiku', 'sonnet', 'opus'];
 const REVIEW_KEYS = ['threshold', 'light', 'full'];
-const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'ux', 'precheck', 'review', 'permissionMode', 'addDirs', 'timeouts'];
+const ORCH_KEYS = ['start', 'verdict', 'test', 'build', 'ux', 'precheck', 'review', 'effort', 'permissionMode', 'addDirs', 'timeouts'];
 /** Clé `orchestrate:` de cadence.yaml. Absente : les défauts (auto, 45 min d'implémentation, 25 min de revue). */
 export function readOrchestrateConfig(file) {
-    const config = { precheck: true, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
+    const config = { precheck: true, review: { threshold: 0.25, light: 'sonnet', full: 'opus' }, effort: { precheck: 'low', implement: 'medium', fix: 'medium', review: 'high', ux: 'high' }, permissionMode: 'auto', addDirs: [], timeouts: { work: 45 * 60_000, review: 25 * 60_000 } };
     if (!existsSync(file))
         return config;
     let raw;
@@ -274,6 +286,17 @@ export function readOrchestrateConfig(file) {
             config.review[k] = m;
         }
     }
+    if (o.effort != null) {
+        if (!isObject(o.effort))
+            throw bad('effort doit être un objet { precheck, implement, fix, review, ux }');
+        for (const [k, v] of Object.entries(o.effort)) {
+            if (!EFFORT_STEPS.includes(k))
+                throw bad(`effort.${k} inconnu (attendu : ${EFFORT_STEPS.join(', ')})`);
+            if (!EFFORTS.includes(v))
+                throw bad(`effort.${k} : ${EFFORTS.join(', ')} attendu`);
+            config.effort[k] = v;
+        }
+    }
     if (o.ux != null) {
         if (typeof o.ux === 'string' && o.ux.trim()) {
             const u = o.ux.trim();
@@ -324,3 +347,69 @@ export function readOrchestrateConfig(file) {
     }
     return config;
 }
+const DOCS_KEYS = ['sync', 'since', 'articles'];
+/** Clé `docs:` de cadence.yaml : `docs.sync`, la documentation qui doit suivre le code. */
+export function readDocsConfig(file) {
+    const none = { sync: [] };
+    if (!existsSync(file))
+        return none;
+    let raw;
+    try {
+        raw = parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new RafError(`${file} illisible : ${e.message.split('\n')[0]}`);
+    }
+    const d = raw?.docs;
+    if (d == null)
+        return none;
+    const bad = (what) => new RafError(`${file} : docs.${what}`);
+    if (!isObject(d))
+        throw new RafError(`${file} : docs doit être un objet { sync, since, articles }`);
+    for (const k of Object.keys(d))
+        if (!DOCS_KEYS.includes(k))
+            throw bad(`${k} inconnu (attendu : ${DOCS_KEYS.join(', ')})`);
+    const config = { sync: [] };
+    if (d.since != null) {
+        if (!isDay(d.since))
+            throw bad(`since « ${String(d.since)} » n'est pas une date AAAA-MM-JJ`);
+        config.since = d.since;
+    }
+    if (d.sync != null) {
+        if (!Array.isArray(d.sync))
+            throw bad('sync doit être une liste de { paths, docs }');
+        d.sync.forEach((r, i) => {
+            if (!isObject(r))
+                throw bad(`sync[${i}] doit être un objet { paths, docs }`);
+            for (const k of Object.keys(r))
+                if (k !== 'paths' && k !== 'docs')
+                    throw bad(`sync[${i}].${k} inconnu (attendu : paths, docs)`);
+            const entry = (key) => {
+                const v = list(r[key]);
+                if (!v.length || v.some((x) => !x.trim()))
+                    throw bad(`sync[${i}].${key} : au moins un chemin non vide attendu`);
+                return v.map((x) => x.trim());
+            };
+            config.sync.push({ paths: entry('paths'), docs: entry('docs') });
+        });
+    }
+    if (d.articles != null) {
+        if (!Array.isArray(d.articles))
+            throw bad('articles doit être une liste de { repo, file }');
+        config.articles = d.articles.map((r, i) => {
+            if (!isObject(r))
+                throw bad(`articles[${i}] doit être un objet { repo, file }`);
+            for (const k of Object.keys(r))
+                if (!['repo', 'file', 'name'].includes(k))
+                    throw bad(`articles[${i}].${k} inconnu (attendu : repo, file, name)`);
+            const text = (key) => {
+                const v = r[key];
+                if (typeof v !== 'string' || !v.trim())
+                    throw bad(`articles[${i}].${key} : texte non vide attendu`);
+                return v.trim();
+            };
+            return { repo: text('repo'), file: text('file'), ...(r.name != null ? { name: text('name') } : {}) };
+        });
+    }
+    return config;
+}

package/dist/deliver.js

@@ -5,6 +5,7 @@ import { onTermination, readProcs, SIGNAL_GRACE_MS, TreeTracker } from './proc.j
 import { isPlanOnly } from './audit.js';
 import { headSha, isAncestor, onRemote, readCommits, repoStatus, resolveCommit } from './git.js';
 import { citedRefs } from './link.js';
+import { describeArticle, openArticleLots } from './articles.js';
 import { RafError } from './plan.js';
 import { appendDelivery, lastDelivery, lockAlive, lockFault, lockPath, readLock, releaseLock, removeStaleLock, writeLock } from './state.js';
 const POLL_CI = 15_000;
@@ -235,6 +236,8 @@ export async function deliver(ctx, deps) {
                 out('    (aucune commande)');
             config.deploy.forEach((c, i) => out(`    ${i + 1}. ${c}`));
         }
+        if (ctx.articles?.length)
+            out(`  Articles rafraîchis après une livraison verte (lot « Article <projet> à rafraîchir ») : ${ctx.articles.map(describeArticle).join(', ')}`);
         if (config.verify.length)
             out(`  Vérifications (réessayées pendant ${config.verifyTimeout} s) :`);
         config.verify.forEach((c, i) => out(`    ${i + 1}. ${describeCheck(c, sha)}`));
@@ -285,7 +288,8 @@ export async function deliver(ctx, deps) {
         const head = script === null || !atHead ? sha : (headSha(ctx.root) ?? sha);
         const moved = head !== sha && isAncestor(ctx.root, sha, head);
         const final = moved ? head : sha;
-        const delivered = deliveredLots(ctx, lastDelivery(ctx.state), final);
+        const ids = deliveredIds(ctx, lastDelivery(ctx.state), final);
+        const delivered = deliveredLots(ctx, ids, lastDelivery(ctx.state), final);
         appendDelivery(ctx.state, ctx.today, final);
         if (moved)
             out(`✓ livré : ${final.slice(0, 7)} (tête déplacée par le script depuis ${env.CADENCE_SHORT})`);
@@ -293,6 +297,7 @@ export async function deliver(ctx, deps) {
             out(`✓ livré${config.verify.length ? ' et vérifié' : ''} : ${env.CADENCE_SHORT}`);
         if (delivered)
             out(delivered);
+        refreshArticles(ctx, ids, final);
         return 0;
     }
     finally {
@@ -407,12 +412,10 @@ async function verifyAll(ctx, deps, sha, env) {
  * nommé pour le contexte — les annoncer « livrés » ferait fermer à tort. L'état est celui du départ de
  * la livraison : le plan a été lu avant que le script du projet ne ferme lui-même les lots qu'il livre.
  */
-function deliveredLots(ctx, prev, sha) {
-    if (!ctx.plan || !prev || prev === sha)
-        return null;
-    if (!isAncestor(ctx.root, prev, sha)) {
-        return `livraison précédente (${prev.slice(0, 7)}) hors de l'historique de ${sha.slice(0, 7)} (réécrit ?) : lots livrés non calculés`;
-    }
+/** Lots cités par les commits livrés depuis la livraison précédente ; vide quand elle est inconnue ou hors de l'historique. */
+function deliveredIds(ctx, prev, sha) {
+    if (!ctx.plan || !prev || prev === sha || !isAncestor(ctx.root, prev, sha))
+        return [];
     const lots = ctx.plan.lots();
     const known = new Set((ctx.plan.readonly ? lots.filter((l) => l.status === 'doing') : lots).map((l) => l.id));
     const ids = new Set();
@@ -423,7 +426,51 @@ function deliveredLots(ctx, prev, sha) {
             if (known.has(r.lot))
                 ids.add(r.lot);
     }
-    if (ids.size === 0)
+    return [...ids].sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+}
+function deliveredLots(ctx, ids, prev, sha) {
+    if (!ctx.plan || !prev || prev === sha)
+        return null;
+    if (!isAncestor(ctx.root, prev, sha)) {
+        return `livraison précédente (${prev.slice(0, 7)}) hors de l'historique de ${sha.slice(0, 7)} (réécrit ?) : lots livrés non calculés`;
+    }
+    if (ids.length === 0)
         return null;
-    return `livré : ${[...ids].sort((a, b) => a.localeCompare(b, undefined, { numeric: true })).join(', ')} — ${ctx.plan.readonly ? "à fermer avec l'outil du projet" : 'raf done'} si l'effet est celui attendu`;
+    return `livré : ${ids.join(', ')} — ${ctx.plan.readonly ? "à fermer avec l'outil du projet" : 'raf done'} si l'effet est celui attendu`;
+}
+/**
+ * Livraison verte (L144) : les lots livrés dont le titre est public changent ce que les articles externes racontent, on ouvre
+ * donc le lot qui les rafraîchit. Le plan est écrit mais pas commité (deliver ne commite jamais) ; une erreur ici ne défait pas
+ * une livraison déjà faite.
+ */
+function refreshArticles(ctx, ids, sha) {
+    if (!ctx.plan || !ctx.articles?.length || !ids.length)
+        return;
+    try {
+        // Relu : le script du projet a pu fermer des lots ou commiter le plan depuis le départ de la livraison, save() ne doit pas l'écraser.
+        const plan = ctx.plan.reloaded();
+        const wanted = new Set(ids);
+        const r = openArticleLots({
+            plan,
+            root: ctx.root,
+            rules: ctx.articles,
+            delivered: plan.lots().filter((l) => wanted.has(l.id)),
+            publicTitle: ctx.publicTitle ?? ((l) => l.public),
+            sha,
+            today: ctx.today,
+        });
+        for (const w of r.warnings)
+            ctx.err(`deliver : ${w}`);
+        if (r.opened.length || r.noted.length)
+            plan.save();
+        for (const id of r.opened)
+            ctx.out(`article à rafraîchir : ${id} « ${plan.lot(id).title} » ouvert (plan modifié, à commiter) — à jouer dans une vague ordinaire`);
+        for (const id of r.noted)
+            ctx.out(`article à rafraîchir : ${id} déjà ouvert, titres livrés ajoutés en note (plan modifié, à commiter)`);
+        for (const m of r.manual)
+            ctx.out(`article à rafraîchir : ${m}`);
+    }
+    catch (e) {
+        ctx.err(`deliver : article à rafraîchir non ouvert — ${e.message}`);
+    }
 }

package/dist/docsync.js

@@ -0,0 +1,57 @@
+import { changedFiles } from './git.js';
+/** Motif de chemin : `*` reste dans un dossier, `**` le traverse, `?` un caractère, un `/` final prend tout le dossier ; sinon chemin exact. */
+export function docSyncMatcher(pattern) {
+    const p = pattern.trim().replace(/\\/g, '/').replace(/^\.\//, '');
+    const source = (p.endsWith('/') ? `${p}**` : p)
+        .split(/(\*\*\/?|\*|\?)/)
+        .map((part) => (part === '**/' ? '(?:.*/)?' : part === '**' ? '.*' : part === '*' ? '[^/]*' : part === '?' ? '[^/]' : part.replace(/[.+^${}()|[\]\\]/g, '\\$&')))
+        .join('');
+    const re = new RegExp(`^${source}$`);
+    return (file) => re.test(file);
+}
+/** Liste de motifs : un fichier en fait partie s'il correspond à un motif et à aucun motif « !… » (exclusion, ex. `!**\/*.test.ts`). */
+export function docSyncSet(patterns) {
+    const yes = patterns.filter((p) => !p.startsWith('!')).map(docSyncMatcher);
+    const no = patterns.filter((p) => p.startsWith('!')).map((p) => docSyncMatcher(p.slice(1)));
+    return (file) => yes.some((m) => m(file)) && !no.some((m) => m(file));
+}
+/** Fichiers modifiés par un ensemble de commits, sans doublon. */
+export function filesOf(root, commits) {
+    return new Set(commits.flatMap((c) => changedFiles(root, c.sha)));
+}
+/** Les règles que ces fichiers enfreignent : ils touchent `paths` sans qu'aucun `docs` ne soit parmi eux. */
+export function docSyncGaps(rules, files) {
+    const gaps = [];
+    for (const rule of rules) {
+        if ([...files].some(docSyncSet(rule.docs)))
+            continue;
+        const inPaths = docSyncSet(rule.paths);
+        const touched = [...files].filter(inPaths).sort();
+        if (touched.length)
+            gaps.push({ rule, touched });
+    }
+    return gaps;
+}
+const SHOWN = 5;
+/** `a, b, c, … (+2)` : les premiers fichiers, le reste compté. */
+function listFiles(files) {
+    return files.length <= SHOWN ? files.join(', ') : `${files.slice(0, SHOWN).join(', ')}, … (+${files.length - SHOWN})`;
+}
+/** La ligne de `raf check` et de `cadence lead tour` pour un lot. */
+export function gapMessage(lot, gap) {
+    return `${lot} : documentation en retard — ${listFiles(gap.touched)} sans toucher ${gap.rule.docs.join(' ou ')} (docs.sync)`;
+}
+/**
+ * Consigne du brief de revue (L143) : la liste calculée par le programme, à passer en constat majeur. Vide sans règle
+ * déclarée ; sans écart, une ligne qui dit que le programme a vérifié (le relecteur juge encore le contenu).
+ */
+export function docSyncBrief(rules, gaps) {
+    if (!rules.length)
+        return '';
+    if (!gaps.length)
+        return 'Documentation (cadence.yaml docs.sync): the program checked that the commits of the lot touch the documents their paths call for. Still read the documents themselves against the change.';
+    return [
+        'Documentation (cadence.yaml docs.sync): the program computed that the commits of the lot touch code without touching the document that describes it. Report ONE MAJOR finding per line below, quoting the line, unless the change really leaves the document true (say why then):',
+        ...gaps.map((g) => `- ${listFiles(g.touched)} changed, but none of ${g.rule.docs.join(', ')} was touched`),
+    ].join('\n');
+}

package/dist/hud-context.js

@@ -0,0 +1,117 @@
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync, unlinkSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { cadenceHome } from './orchestrate/registry.js';
+/** Au-delà, le chiffre écrit par la bande est trop vieux pour guider un arrêt (la bande le rafraîchit toutes les 5 s). */
+export const HUD_CONTEXT_MAX_AGE_MS = 120_000;
+/** Un fichier de session plus vieux que cela est ignoré et supprimé à la lecture (une session fermée ne le rafraîchit plus). */
+export const HUD_CONTEXT_PURGE_MS = 24 * 3600_000;
+/** Dossier où la bande cadence-hud publie le contexte de chaque session : un fichier `<id de session>.json` par session. */
+export function hudContextDir(env = process.env) {
+    return join(cadenceHome(env), 'hud-context');
+}
+/** Le nom de fichier d'une session : le même nettoyage que le script d'écriture de la bande (lettres, chiffres, `-`, `_`). */
+export function hudContextFile(session) {
+    return `${session.replace(/[^A-Za-z0-9_-]/g, '_')}.json`;
+}
+function sameFolder(a, b) {
+    const real = (p) => {
+        try {
+            return realpathSync(p);
+        }
+        catch {
+            return resolve(p);
+        }
+    };
+    return real(a) === real(b);
+}
+const isNum = (n) => typeof n === 'number' && Number.isFinite(n);
+/** Retire les fichiers de plus de 24 h (selon `at`, ou la date du fichier quand `at` manque) ; rend les autres. */
+function livingFiles(dir, nowMs) {
+    const kept = [];
+    for (const name of readdirSync(dir)) {
+        if (!name.endsWith('.json'))
+            continue;
+        const file = join(dir, name);
+        let at;
+        try {
+            const raw = JSON.parse(readFileSync(file, 'utf8'));
+            if (isNum(raw?.at))
+                at = raw.at;
+        }
+        catch {
+            /* illisible : l'âge du fichier décide */
+        }
+        try {
+            at ??= statSync(file).mtimeMs;
+            if (nowMs - at > HUD_CONTEXT_PURGE_MS) {
+                unlinkSync(file);
+                continue;
+            }
+        }
+        catch {
+            continue;
+        }
+        kept.push(file);
+    }
+    return kept;
+}
+/** La variable que Claude Code pose dans l'environnement de ses commandes Bash : l'id de la session, nom du fichier que la bande écrit. */
+export const SESSION_ID_ENV = 'CLAUDE_CODE_SESSION_ID';
+/**
+ * Le contexte publié par la bande pour la session de l'appelant, dans l'ordre : `session` quand on la désigne, sinon la session de la
+ * variable `CLAUDE_CODE_SESSION_ID` ; seulement si elle est absente ET qu'un seul fichier publie pour `cwd`, celui-là (deux sessions
+ * d'un même dossier alternent : « la plus récente » donnerait le chiffre de l'autre, d'où le refus). Sinon une raison de ne pas le croire
+ * (aucune session, plusieurs, illisible, incomplet, périmé).
+ */
+export function readHudContext(env, nowMs, target) {
+    const dir = hudContextDir(env);
+    if (!existsSync(dir))
+        return { ok: false, reason: `${dir} absent (le mod cadence-hud est-il chargé ?)` };
+    const files = livingFiles(dir, nowMs);
+    let file;
+    let unreadable = 0;
+    const fromEnv = target.session === undefined && !!env[SESSION_ID_ENV];
+    const session = target.session ?? (env[SESSION_ID_ENV] || undefined);
+    if (session !== undefined) {
+        file = join(dir, hudContextFile(session));
+        if (!files.includes(file))
+            return { ok: false, reason: `aucun contexte publié pour la session ${session}${fromEnv ? ` (variable ${SESSION_ID_ENV})` : ''} (${file} absent ; le mod cadence-hud est-il chargé dans cette session ?)` };
+    }
+    else {
+        const found = [];
+        for (const f of files) {
+            try {
+                const raw = JSON.parse(readFileSync(f, 'utf8'));
+                if (typeof raw?.cwd === 'string' && sameFolder(raw.cwd, target.cwd))
+                    found.push({ file: f, at: isNum(raw.at) ? raw.at : -Infinity });
+            }
+            catch {
+                unreadable++;
+            }
+        }
+        // Un fichier périmé est une session close ou muette, pas une rivale : elle ne compte parmi les candidates que si aucune n'est fraîche.
+        const fresh = found.filter((c) => nowMs - c.at <= HUD_CONTEXT_MAX_AGE_MS);
+        const candidates = (fresh.length ? fresh : found).map((c) => c.file);
+        if (candidates.length > 1)
+            return { ok: false, reason: `plusieurs sessions dans ce dossier (${candidates.map((f) => basename(f, '.json')).join(', ')}) et ${SESSION_ID_ENV} absente : passer --session <id>` };
+        file = candidates[0];
+        if (!file) {
+            const more = unreadable ? ` ; ${unreadable} fichier(s) illisible(s)` : '';
+            return { ok: false, reason: `aucune session de la bande ne publie pour ${target.cwd} dans ${dir} (le mod cadence-hud est-il chargé dans cette session ?)${more}` };
+        }
+    }
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return { ok: false, reason: `${file} illisible` };
+    }
+    const { cwd, percent, tokens, window, at } = raw;
+    if (typeof cwd !== 'string' || ![percent, tokens, window, at].every(isNum))
+        return { ok: false, reason: `${file} incomplet` };
+    const age = nowMs - at;
+    if (age > HUD_CONTEXT_MAX_AGE_MS)
+        return { ok: false, reason: `${file} périmé (${Math.round(age / 1000)} s)` };
+    return { ok: true, ctx: { cwd, percent: percent, tokens: tokens, window: window, at: at } };
+}

package/dist/lead.js

@@ -1,23 +1,25 @@
 import { existsSync, readdirSync, statSync } from 'node:fs';
-import { basename, join, resolve } from 'node:path';
+import { basename, join } from 'node:path';
 import { audit, nextUp, planCommits } from './audit.js';
-import { readPlanConfig } from './config.js';
+import { planLoader, readPlanConfig } from './config.js';
 import { diffDays } from './dates.js';
 import { gitRoot, repoStatus } from './git.js';
 import { linkCommits } from './link.js';
-import { Plan } from './plan.js';
 import { lastActivity, lockStatus } from './session.js';
+import { priorityRank, readPriority } from './orchestrate/continue.js';
 import { readNext, sharedStateDir, stateDir } from './state.js';
 export const NOTES_MAX = 120;
 export const TITLE_MAX = 60;
 /** Au-delà de ce nombre de jours sans activité, un lot en cours est dit silencieux. */
 export const TOUR_IDLE = 3;
-const empty = (project) => ({ project, doing: [], drift: [], notes: [], next: null, repo: [] });
+/** Un lot créé depuis moins de ce nombre de jours (aujourd'hui compris : 0 à 6 jours d'écart) compte parmi les « ajoutés cette semaine ». */
+export const ADDED_DAYS = 7;
+const empty = (project) => ({ project, doing: [], drift: [], notes: [], next: null, progress: { done: 0, doing: 0, todo: 0, added7: 0 }, repo: [] });
 export function truncate(text, max) {
     return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
 /** Un dossier est un projet s'il porte docs/plan/raf.yaml, ou un cadence.yaml avec `plan:`. */
-function isProject(dir) {
+export function isProject(dir) {
     if (existsSync(join(dir, 'docs/plan/raf.yaml')))
         return true;
     const conf = join(dir, 'cadence.yaml');
@@ -58,10 +60,7 @@ export function tourRow(dir, today, idle = TOUR_IDLE) {
     const row = empty(basename(dir));
     try {
         const root = gitRoot(dir) ?? dir;
-        const configPath = join(root, 'cadence.yaml');
-        const planConfig = readPlanConfig(configPath, root);
-        const planPath = resolve(root, planConfig?.path ?? 'docs/plan/raf.yaml');
-        const plan = Plan.load(planPath, { ...planConfig?.settings, config: configPath });
+        const plan = planLoader(root)();
         const lots = plan.lots();
         const all = linkCommits(lots, planCommits(plan, root), plan.refs);
         const { doing, ready } = nextUp(lots);
@@ -74,6 +73,13 @@ export function tourRow(dir, today, idle = TOUR_IDLE) {
         });
         row.drift = audit(plan, root, join(root, 'docs/nouveautes'), today).map((i) => `${i.warning ? '⚠' : '✗'} ${i.message}`);
         row.notes = readNext(stateDir(root))?.lines ?? [];
+        const counted = lots.filter((l) => l.status !== 'dropped' && l.every === undefined);
+        row.progress = {
+            done: counted.filter((l) => l.status === 'done').length,
+            doing: counted.filter((l) => l.status === 'doing').length,
+            todo: counted.filter((l) => l.status === 'todo').length,
+            added7: counted.filter((l) => l.created !== undefined && diffDays(l.created, today) >= 0 && diffDays(l.created, today) < ADDED_DAYS).length,
+        };
         row.next = ready[0] ? { id: ready[0].id, title: ready[0].title } : null;
         const s = repoStatus(root);
         if (s.dirty || s.untracked)
@@ -88,8 +94,26 @@ export function tourRow(dir, today, idle = TOUR_IDLE) {
     }
     return row;
 }
+/**
+ * Les projets rangés par la clé `priority:` du cadence.yaml du dossier (L149) ; les autres après, par ordre alphabétique.
+ * Une priorité illisible ou invalide ne vide pas le tableau : l'ordre alphabétique reste, et une première ligne `cadence.yaml` en erreur le dit.
+ * Un dossier qui n'a aucun sous-projet mais est lui-même un projet donne la ligne de ce projet seul (la bande l'interroge depuis le dossier de la session).
+ */
 export function leadTour(parent, today, idle = TOUR_IDLE) {
-    return findProjects(parent).map((dir) => tourRow(dir, today, idle));
+    const dirs = findProjects(parent);
+    if (dirs.length === 0 && isProject(parent))
+        return [tourRow(parent, today, idle)];
+    const rows = dirs.map((dir) => tourRow(dir, today, idle));
+    let priority = [];
+    let problem;
+    try {
+        priority = readPriority(parent);
+    }
+    catch (e) {
+        problem = { ...empty('cadence.yaml'), error: (e instanceof Error ? e.message : String(e)).split('\n')[0] };
+    }
+    const sorted = rows.map((r, i) => ({ r, i })).sort((a, b) => priorityRank(a.r.project, priority) - priorityRank(b.r.project, priority) || a.i - b.i).map((x) => x.r);
+    return problem ? [problem, ...sorted] : sorted;
 }
 const DRIFT_SHOWN = 2;
 /** Une ligne par projet : projet · en cours · dérive · notes · prochain lot prêt · dépôt. */

package/dist/orchestrate/briefs.js

@@ -69,7 +69,7 @@ export function loadTemplates(dir = TEMPLATES_DIR) {
 export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
     const text = typeof source === 'string' ? loadTemplates(source)[kind] : source[kind];
     const out = text.replace(/\{\{(\w+)\}\}/g, (_m, name) => {
-        const v = { ...vars, repos: vars.repos ?? '' }[name];
+        const v = { ...vars, repos: vars.repos ?? '', docs: vars.docs ?? '' }[name];
         if (v === undefined)
             throw new RafError(`gabarit ${FILES[kind]} : valeur manquante pour {{${name}}}`);
         return v;