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

package/README.md

@@ -24,7 +24,7 @@ Code prompt that shows the session's context, quota, cost and the orchestrate wa
 
 ## What's new
 
-**0.13.1**: `cadence-hud` takes back the segments that fit once a big one has dropped (reset times, then the per-model consumption, now short: `opus 1.2M sonnet 800k`); `CADENCE_HUD_AMBIGUOUS=1` for a terminal that draws `▰ ▱ ⚙ │ ↻` in one cell. **0.13.0**: `cadence orchestrate --status --watch` (a wave's table redrawn in the terminal, which
+**0.14.0**: `cadence lead tour`, the lead's morning table of every project in a folder, printed by a program (one line per project: lots in progress, gaps, last notes, next ready lot, repository) in place of one subagent per project; the `lead` skill calls it. **0.13.1**: `cadence-hud` takes back the segments that fit once a big one has dropped (reset times, then the per-model consumption, now short: `opus 1.2M sonnet 800k`); `CADENCE_HUD_AMBIGUOUS=1` for a terminal that draws `▰ ▱ ⚙ │ ↻` in one cell. **0.13.0**: `cadence orchestrate --status --watch` (a wave's table redrawn in the terminal, which
 stops with the wave) and the lead skill that names the wave and follows its journal; lot ids with `/`
 (sub-tasks of a read-only plan) accepted by `orchestrate`; `cadence-hud`'s first line measured in
 terminal cells and kept to ASCII; `publish.yml` on the v5 actions. **0.12.0**: the `cadence-hud` plugin (a status band above the Claude Code prompt),
@@ -455,6 +455,32 @@ The commands get `CADENCE_SINCE` (the `--since` in effect) and `CADENCE_TODAY`.
 add facts and decide nothing: a failing command is reported and changes neither
 the exit code nor the verdict.
 
+## lead tour
+
+`cadence lead tour [folder] [--idle 3] [--json]` is the lead's morning table, with no model in
+the loop. From a parent folder (default: the current one) it takes every direct sub-folder that
+holds `docs/plan/raf.yaml`, or a `cadence.yaml` with a `plan:` key (a plan kept by another tool
+included), and for each one reads the same facts as `cadence session start` — in-process, no
+sub-process, no call to `claude` — then prints **one line per project**:
+
+```
+alpha · en cours L1 (silencieux 4j) · dérive 1 (✗ L2 a 1 commit(s) mais est encore todo) · notes : finir L1 puis livrer · prochain L3 Typo · dépôt non commité, non poussé
+beta · en cours rien · dérive aucune · notes : aucune · prochain T2 Second · dépôt propre
+```
+
+| Column | Content |
+|---|---|
+| `en cours` | ids of the lots in progress; `(aucune activité)` when it has none at all, `(silencieux Nj)` when the lot's last activity (commit, note or start) is more than `--idle` days old (default 3) |
+| `dérive` | the gaps `raf check` reports, counted and the first two shown |
+| `notes` | the notes left by the last `session close`, joined with ` / ` and cut at 120 characters |
+| `prochain` | the first ready lot (quick wins first) — id and title cut at 60 characters |
+| `dépôt` | `non commité` (modified or untracked files), `non poussé` (commits ahead of the upstream), `livraison en cours` (live delivery lock); `propre` otherwise |
+
+`--json` prints the same content as an array of objects (`project`, `doing`, `drift`, `notes`,
+`next`, `repo`, and `error` when the project could not be read). The tour is read-only: it changes
+no plan. It exits 0 even when a project is in error — that project's line reads
+`beta · ✗ erreur : <cause>`. The `lead` skill runs it instead of one subagent per project.
+
 ## deliver
 
 A delivery is done when its checks pass, not when a tool says "success".
@@ -937,8 +963,8 @@ repository with `cadence skills install` (to `.claude/skills/cadence-*` and
 - **deliver**: dry run, delivery, and on failure the cause fixed rather than a
   blind retry; after a green delivery that changes what a page shows or what it
   is served, the `qa-reviewer` agent walks the delivered app.
-- **lead**: from a folder holding several projects, one subagent per project
-  gathers the facts, you choose the priorities, the lots are delegated with
+- **lead**: from a folder holding several projects, `cadence lead tour` (a program,
+  no model: see [lead tour](#lead-tour)) prints one line of facts per project, you choose the priorities, the lots are delegated with
   `cadence orchestrate` (fresh short sessions with a standard brief — test first,
   README and usage documentation updated with the change, commits citing the lot, no push — reviewed by the `code-reviewer` agent, see
   [orchestrate](#orchestrate)), re-verified by the lead, then delivered

package/bin/cadence.js

@@ -13,7 +13,7 @@ const io = {
 
 if (tool === 'raf') {
   process.exitCode = await run(args, io);
-} else if (['news', 'session', 'deliver', 'verify', 'skills', 'orchestrate'].includes(tool)) {
+} else if (['news', 'session', 'deliver', 'verify', 'skills', 'orchestrate', 'lead'].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'));
@@ -37,6 +37,8 @@ if (tool === 'raf') {
   cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--max-sessions 2] [--wave id] [--dry-run]
                     une session claude neuve par étape (implémentation, revues, corrections) ; --status, --resume ;
                     --max-sessions : sessions simultanées, toutes vagues confondues (CADENCE_MAX_SESSIONS)
+  cadence lead tour [dossier] [--idle 3] [--json]
+                    le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan
   cadence skills install [--dir .claude] [--force]
                     installe les skills Claude Code session-start, session-close, deliver et l'agent ux-reviewer`);
   process.exitCode = !tool || ['help', '--help', '-h'].includes(tool) ? 0 : 2;

package/dist/cli.js

@@ -16,6 +16,7 @@ import { Plan, RafError, STATUSES } from './plan.js';
 import { dueLine, isRecurring, recurringByDue } from './recurring.js';
 import { schedule } from './schedule.js';
 import { AGENTS_DIR, installAgents, installSkills, SKILLS_DIR } from './skills.js';
+import { leadTour, tourLine } from './lead.js';
 import { orchestrate, realOrchestrateDeps } from './orchestrate/command.js';
 import { activeLock, REPO_LOCK } from './orchestrate/lock.js';
 import { sessionClose, sessionStart } from './session.js';
@@ -41,6 +42,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf gantt [-o docs/plan/gantt.html]
   raf hook install
   cadence orchestrate <projet>:<lot>[@modèle]… [--budget 2M] [--dry-run] [--wave nom]   une session claude neuve par étape ; --status [vague] [--watch [--interval s]] ; --resume [vague] [--budget 1M] [--answer projet:lot "réponse"]
+  cadence lead tour [dossier] [--idle 3] [--json]   le tableau du lead, sans modèle : une ligne par sous-dossier qui a un plan (en cours, dérive, notes de clôture, prochain lot prêt, dépôt)
   cadence verify [--retry s] [--sha rév]   rejoue deliver.verify hors livraison : 0 vert, 1 effet rouge, 2 rien à vérifier
   raf news new <lot…> [--title t] | list | check | stamp | build [-o dossier]   (aussi « cadence news … »)
 
@@ -120,6 +122,7 @@ function dispatch(argv, io) {
             clear: { type: 'boolean' },
             ignored: { type: 'boolean' },
             notes: { type: 'boolean' },
+            json: { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
         },
     });
@@ -132,6 +135,26 @@ function dispatch(argv, io) {
     if (!isDay(today))
         throw new RafError(`RAF_TODAY invalide : ${today} (attendu AAAA-MM-JJ)`);
     const root = gitRoot(io.cwd) ?? io.cwd;
+    // Le tour parcourt les sous-dossiers : il ne lit ni le plan ni le cadence.yaml du dossier courant.
+    if (command === 'lead') {
+        if (rest[0] !== 'tour' || rest.length > 2)
+            throw new RafError('usage : cadence lead tour [dossier] [--idle 3] [--json]');
+        const idle = values.idle === undefined ? undefined : Number(values.idle);
+        if (idle !== undefined && !(Number.isInteger(idle) && idle >= 0))
+            throw new RafError(`--idle invalide : ${values.idle}`);
+        const parent = resolve(io.cwd, rest[1] ?? '.');
+        if (!existsSync(parent))
+            throw new RafError(`lead tour : dossier introuvable : ${parent}`);
+        const rows = leadTour(parent, today, idle);
+        if (values.json)
+            io.out(JSON.stringify(rows, null, 2));
+        else if (rows.length === 0)
+            io.out(`aucun projet sous ${parent} (docs/plan/raf.yaml ou cadence.yaml avec plan:)`);
+        else
+            for (const r of rows)
+                io.out(tourLine(r));
+        return 0;
+    }
     // cadence.yaml peut dire où est le plan et, s'il est tenu par un autre outil, comment le lire.
     const configPath = resolve(io.cwd, values.config ?? join(root, 'cadence.yaml'));
     // Installer les skills ou le hook ne lit pas le plan : un cadence.yaml fautif ne doit pas l'empêcher.

package/dist/lead.js

@@ -0,0 +1,91 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { audit, nextUp, planCommits } from './audit.js';
+import { 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 { 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: [] });
+export function truncate(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+/** Sous-dossiers directs qui portent un plan : docs/plan/raf.yaml, ou un cadence.yaml avec `plan:`. */
+export function findProjects(parent) {
+    return readdirSync(parent, { withFileTypes: true })
+        .filter((e) => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules')
+        .map((e) => join(parent, e.name))
+        .filter((dir) => {
+        if (existsSync(join(dir, 'docs/plan/raf.yaml')))
+            return true;
+        const conf = join(dir, 'cadence.yaml');
+        if (!existsSync(conf) || !statSync(conf).isFile())
+            return false;
+        try {
+            const c = readPlanConfig(conf);
+            // Une clé qa: seule ne désigne aucun plan.
+            return !!c && (!!c.path || Object.keys(c.settings).some((k) => k !== 'qaExpectations'));
+        }
+        catch {
+            return true; // un cadence.yaml illisible reste un projet : sa ligne dit l'erreur
+        }
+    })
+        .sort();
+}
+/** Les faits de `cadence session start` pour un projet, sous forme de données ; lecture seule. */
+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 lots = plan.lots();
+        const all = linkCommits(lots, planCommits(plan, root), plan.refs);
+        const { doing, ready } = nextUp(lots);
+        row.doing = doing.map((l) => {
+            const last = lastActivity(l, all.byLot.get(l.id) ?? []);
+            if (!last)
+                return { id: l.id, noActivity: true };
+            const days = diffDays(last, today);
+            return days > idle ? { id: l.id, silentDays: days } : { id: l.id };
+        });
+        row.drift = audit(plan, root, join(root, 'docs/nouveautes'), today).map((i) => `${i.warning ? '⚠' : '✗'} ${i.message}`);
+        row.notes = readNext(stateDir(root))?.lines ?? [];
+        row.next = ready[0] ? { id: ready[0].id, title: ready[0].title } : null;
+        const s = repoStatus(root);
+        if (s.dirty || s.untracked)
+            row.repo.push('non commité');
+        if (s.ahead)
+            row.repo.push('non poussé');
+        if (lockStatus(sharedStateDir(root))?.live)
+            row.repo.push('livraison en cours');
+    }
+    catch (e) {
+        return { ...empty(row.project), error: (e instanceof Error ? e.message : String(e)).split('\n')[0] };
+    }
+    return row;
+}
+export function leadTour(parent, today, idle = TOUR_IDLE) {
+    return findProjects(parent).map((dir) => tourRow(dir, today, idle));
+}
+const DRIFT_SHOWN = 2;
+/** Une ligne par projet : projet · en cours · dérive · notes · prochain lot prêt · dépôt. */
+export function tourLine(r) {
+    if (r.error)
+        return `${r.project} · ✗ erreur : ${r.error}`;
+    const doing = r.doing.length ? r.doing.map((d) => (d.noActivity ? `${d.id} (aucune activité)` : d.silentDays === undefined ? d.id : `${d.id} (silencieux ${d.silentDays}j)`)).join(', ') : 'rien';
+    const drift = r.drift.length
+        ? `${r.drift.length} (${r.drift.slice(0, DRIFT_SHOWN).join(' ; ')}${r.drift.length > DRIFT_SHOWN ? ' ; …' : ''})`
+        : 'aucune';
+    const notes = r.notes.length ? truncate(r.notes.join(' / '), NOTES_MAX) : 'aucune';
+    const next = r.next ? `${r.next.id} ${truncate(r.next.title, TITLE_MAX)}` : 'aucun';
+    return [r.project, `en cours ${doing}`, `dérive ${drift}`, `notes : ${notes}`, `prochain ${next}`, `dépôt ${r.repo.length ? r.repo.join(', ') : 'propre'}`].join(' · ');
+}

package/dist/session.js

@@ -46,7 +46,7 @@ function byLotLines(linked) {
     });
 }
 /** Ligne de livraison en cours ; `live` faux quand le verrou appartient à un processus mort. */
-function lockStatus(state) {
+export function lockStatus(state) {
     const lock = readLock(state);
     if (!lock)
         return null;
@@ -77,7 +77,7 @@ function section(out, title, lines) {
         out(`  ${l}`);
 }
 /** Dernière activité d'un lot : dernier commit, dernière note ou démarrage. */
-function lastActivity(lot, commits) {
+export function lastActivity(lot, commits) {
     const days = [commits[0]?.day, lot.started, ...lot.notes.map((n) => n.date)].filter((d) => !!d);
     return days.length ? days.reduce(maxDay) : undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylad/cadence",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "description": "A small, repo-native working method: a versioned plan linked to your commits, a changelog with screenshots, session rituals and deliveries proven by their effect.",
   "license": "MIT",
   "author": "Sylvain Ladoire",

package/skills/lead/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: lead
-description: Lead several cadence projects from a parent folder without loading them into the main context — fan out one subagent per project to gather the facts, agree the priorities with the human, delegate each chosen lot to a subagent with a standard brief, have the work reviewed, re-verify it yourself, then deliver one project at a time. Triggers — "/lead", "pilot all projects", "on pilote tout", "délègue aux sous-agents", start of a multi-project day.
+description: Lead several cadence projects from a parent folder without loading them into the main context — take the facts of every project with `cadence lead tour`, agree the priorities with the human, delegate each chosen lot to a subagent with a standard brief, have the work reviewed, re-verify it yourself, then deliver one project at a time. Triggers — "/lead", "pilot all projects", "on pilote tout", "délègue aux sous-agents", start of a multi-project day.
 ---
 
 # Lead — decide at the top, work in subagents
 
 The lead session stays small: it reads summaries, decides with the human, delegates, checks and
-delivers. Project files are read and changed by subagents, each with its own context. The projects
+delivers. Project files are changed by subagents, each with its own context; the facts of the tour come from `cadence lead tour`, a program. The projects
 are the sub-folders of the current directory that contain `docs/plan/raf.yaml`, or a `cadence.yaml`
 with a `plan:` key. A project whose `cadence.yaml` maps the fields of a plan kept by its own tool is
 **read-only** for `raf`: it takes part in the tour, and its plan is changed with the project's own
@@ -30,9 +30,12 @@ commands (its CLAUDE.md names them), never with `raf start|done|note|ux|review`.
 
 ## 1. Tour of the projects
 
-For each project, a subagent (read-only) runs `cd <project> && cadence session start` and returns at
-most five lines: lots in progress (silent ones flagged), drift, notes from the last close, the next
-ready lot. Two at a time, in the background.
+Run `cadence lead tour` from the parent folder (one command, no subagent, no model: it reads the same
+facts as `cadence session start` for every project). It prints one line per project — lots in progress
+(`silencieux Nj` when idle for more than three days), drift, notes from the last close, the next ready lot,
+repository state — and exits 0 even when a project is in error (its line says so). `--json` gives the same
+content. Read the lines yourself; open a project's own `cadence session start` only for the one you need to
+look at closer.
 
 Then report to the human in a compact table — one row per project — and propose **three** items
 across projects, each with project, lot id and one sentence of justification: finish what is in