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

package/README.md

@@ -24,7 +24,10 @@ Code prompt that shows the session's context, quota, cost and the orchestrate wa
 
 ## What's new
 
-**0.12.0**: the `cadence-hud` plugin (a status band above the Claude Code prompt),
+**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),
 `raf ignore` to acknowledge a commit without a lot, waves that size the review to the lot,
 hand back a lot whose deliverable is already there and start the app themselves for the UX
 review (`orchestrate.ux`), and briefs that require the README to follow the change. **0.11.0**: waves on different repositories run side by side under a shared cap of
@@ -481,7 +484,7 @@ news:
   publicTitleMax: 80      # characters; without the key, `raf check` warns at 80 in a project that has a news directory
 ```
 
-`raf check` also warns (`⚠`, not an error: exit code 0 if nothing else is wrong) about every visible lot, dropped ones excepted, that has no public title: the site would show its technical title (a done lot cited by a News entry is spared: the site reuses that entry's title). Fix it with `raf public <id> "…"`.
+`raf check` also warns (`⚠`, not an error: exit code 0 if nothing else is wrong) about every visible lot, dropped ones excepted, that has no public title: the site would show its technical title (a done lot cited by a News entry is spared: the site reuses that entry's title). Fix it with `raf public <id> "…"`. On a plan kept by another tool (read-only), the warning only applies if `plan.fields` maps a `public` field, or if some lot already carries a literal `public:` key (a field left out is read under its own name): without either there is no public title to set, so it would come back at every session.
 
 With the key, `raf public`, `raf add --public`, `raf done` (on a lot whose public title is too long) and
 `cadence news new` (its title) refuse above it; without it, only `raf check` warns.
@@ -664,18 +667,32 @@ exception is a **formatting retry** (below).
 ```sh
 cadence orchestrate finance-tracker:L41 ol-companion:L22 cadence:L18@haiku
 cadence orchestrate L18                      # from inside a project
+cadence orchestrate maritime-atlas:Q4/accueil-4-ux12@haiku   # a lot id may contain "/" (sub-tasks of read-only plans)
 cadence orchestrate … --budget 1.5M          # 1500000, 1.5M, 800k; default 2M
 cadence orchestrate … --max-sessions 3       # sessions running at the same moment, all waves together; default 2
 cadence orchestrate … --dry-run              # preconditions + the plan of the wave; nothing is started
 cadence orchestrate --status [<wave>]        # the live waves and the repositories they hold, then the table (default: the last wave of this folder)
+cadence orchestrate --status [<wave>] --watch [--interval 10]   # the same, redrawn every 10 s (--interval in seconds); stops by itself when no wave is running (with an explicit `<wave>`: when that wave is no longer running)
 cadence orchestrate --resume [<wave>] [--budget 1M] [--answer ol-companion:L22 "reply"]
 ```
 
+**Lot ids containing `/` (L120)**: the first `:` separates the project from the lot, a final `@` the model, and the lot
+keeps its `/` (`maritime-atlas:Q4/accueil-4-ux12@haiku`); this holds for `--dry-run`, `--status`, `--resume` and
+`--answer` too. In `.cadence/runs/<wave>/` the `/` of the lot becomes `__` (`maritime-atlas--Q4__accueil-4-ux12.json`,
+same for the lot folder and the dry-run briefs); ids without `/` are unchanged.
+
 You choose the lots; the order is the order given (one queue per repository, as many repositories at the
 same time as the session cap allows — 2 by default). `@haiku|@sonnet|@opus` sets the model of the implementation and corrections of that
 lot (default Sonnet; reviews are Opus, except the light review below; Haiku only when you write it, for a mechanical lot). Run it
 in the background and read `--status`: it prints one line per transition and the final table.
 
+**Following a wave (L49)**: `--status --watch` clears the screen and redraws the live waves and the table every
+`--interval` seconds (default 10), then stops by itself, leaving the last render, as soon as no wave is running
+(exit code 0, like `--status`; a wave already finished gives a single render). The `cadence-lead` skill names the background
+task « vague `<id>` : `<project>:<lot>`, … », starts the wave with `--wave <id>` and arms a follow-up on
+`.cadence/runs/<id>/journal.log` that pushes each transition (lot → state, question, ready, handed back) into the conversation.
+The Claude Code status band is the `cadence-hud` plugin.
+
 **Cycle of a lot**: preconditions (clean tracked files, lot `todo` or `doing`, dependencies met) →
 `raf start` (committed alone) → implementation → **UX review** if the lot is `visible` and the app is
 declared → **code review**, which always comes last (a UX fix changes code) → compliant (no blocking, no
@@ -797,7 +814,7 @@ lists the commits already present; finished steps are never replayed.
 Briefs are the templates of `templates/orchestrate/` (`implement.md` is the `lead` skill's standard
 brief; `--dry-run` writes the rendered ones). The `implement` brief of a `visible` lot also carries the
 News instruction (`cadence news new <lot>`, factual user-side text, a screenshot in `docs/nouveautes/captures/` or
-`nocapture:`, `cadence news check` green); the brief gives the absolute path of the wave's Playwright output directory and the `implement` session gets `--add-dir` on it, to copy the capture into the repository; a lot that is not `visible` gets nothing. A project can declare, in `cadence.yaml`:
+`nocapture:`, `cadence news check` green); the brief gives the absolute path of the wave's Playwright output directory and the `implement` session gets `--add-dir` on it, to copy the capture into the repository; the `fix` and `fix-minors` briefs of a `visible` lot give the same folder (and their sessions the same `--add-dir`), to fetch a screenshot a finding asks for; a lot that is not `visible` gets nothing. A `--dry-run` brief of a `visible` lot has no wave folder (the wave does not exist yet), nor does a brief delegated by hand: the News instruction then says to save the screenshot under the OS temp directory, never inside the repository, then copy it into `docs/nouveautes/captures/`. A project can declare, in `cadence.yaml`:
 
 ```yaml
 orchestrate:
@@ -962,9 +979,9 @@ repository with `cadence skills install` (to `.claude/skills/cadence-*` and
 A band above the Claude Code prompt (terminal and desktop app), refreshed every 5 s:
 
 ```
-ctx ▰▰▰▰▱▱▱▱▱▱  42 % 84k/200k  │  5h  23 % ↻ 2 h 10  │  7j  61 % ↻ 6 j 15 h  │  $1.23  │  fable 410k $0.95 · sonnet 85k $0.12  │  ⚙ 2 agents
+ctx ▰▰▰▰▱▱▱▱▱▱  42 % 84k/200k  │  5h  23 % ↻ 2 h 10  │  7j  61 % ↻ 6 j 15 h  │  $1.23  │  fable 410k sonnet 85k  │  ⚙ 2 agents
 ⟳ cadence · 2026-10-07-2131 en cours  │  budget ▱▱▱▱▱▱▱▱▱▱   1 % 14k/2M  │  1 session/2
-  L112  implémente  implement@sonnet 34 s         global-setup coupe le cache de compilation de Node…
+  L112  implémente  implement@sonnet 34 s         global-setup coupe le cache de compilation de Node...
 ```
 
 Context of the session (green / orange / red at 50 and 75 %), the 5-hour and 7-day quota

package/dist/audit.js

@@ -109,7 +109,7 @@ export function audit(plan, root, newsDir, today, opts = {}) {
         const m = l.public ? publicTitleTooLong(l.public, max) : reused ? publicTitleTooLong(reused, max) : null;
         return m ? [{ message: `${l.id} : ${reused && !l.public ? m.replace('titre public', 'titre public repris de la Nouveauté') : m}` }] : [];
     });
-    const issues = [...check(lots, { ...linked, byLot: all.byLot }, today, opts.idle ?? 7), ...newsIssues(lots, entries, newsDir), ...titles, ...gates, ...missingPublicTitles(lots, entries),
+    const issues = [...check(lots, { ...linked, byLot: all.byLot }, today, opts.idle ?? 7), ...newsIssues(lots, entries, newsDir), ...titles, ...gates, ...(plan.hasPublicField ? missingPublicTitles(lots, entries) : []),
         ...plan.ignore.invalid.map((src) => ({ message: `ignore : motif invalide « ${src} »` }))];
     // Un plan en lecture seule se corrige avec l'outil du projet : ne pas conseiller une commande raf qui refuserait.
     return plan.readonly ? issues.map((i) => ({ ...i, message: i.message.replace(/ — raf (start|public) .*$/, '') })) : issues;

package/dist/cli.js

@@ -40,7 +40,7 @@ const HELP = `raf — plan « reste à faire » versionné dans le dépôt, reli
   raf ignore <sha> | "<sujet exact>" [--reason texte]   acquitte un commit sans lot (ou citant un id inconnu) sans réécrire l'historique ; raf check --ignored les liste
   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] ; --resume [vague] [--budget 1M] [--answer projet:lot "réponse"]
+  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 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 … »)
 

package/dist/orchestrate/command.js

@@ -18,7 +18,7 @@ import { buildArgs, killSessions, mcpServersFor, readAgents, realClaude } from '
 import { activeLock, REPO_LOCK, releaseLock, takeLock } from './lock.js';
 import { runPool } from './pool.js';
 import { schemaFor } from './schemas.js';
-import { excludeState, lotKey, newLot, RunStore } from './state.js';
+import { excludeState, lotKey, lotSlug, newLot, RunStore } from './state.js';
 import { linkNodeBin, nvmVersionsDir, resolveNode } from './node-env.js';
 import { quotaText, renderTable } from './table.js';
 import { PACKAGE_ROOT, RESERVED_ENV, SnapshotRefusal, isSnapshotChild, resolveModulesDir, snapshotExists, withoutLaunchVars, spawnReexec, takeSnapshot, toolDirOf } from './snapshot.js';
@@ -45,10 +45,12 @@ export function parseMaxSessions(text, what = '--max-sessions') {
         throw new RafError(`${what} invalide : ${text} (entier ≥ 1)`);
     return Number(text);
 }
-const LOT_LIKE = /^(?:[\w.-]+:)?[A-Za-z]+\d+(?:@\w+)?$/;
+// une vague (2026-10-04-1412) n'a ni « : » ni « / » : leur présence désigne un lot, quel que soit son motif (R-M7/ux-1)
+const LOT_LIKE = /^(?:[\w.-]+:[\w.-][\w./-]*|[\w.-]+\/[\w./-]*|[A-Za-z]+\d+)(?:@\w+)?$/;
 const MODELS = ['sonnet', 'opus', 'haiku'];
 function lotArg(text) {
-    const m = /^(?:([\w.-]+):)?([\w.-]+?)(?:@(\w+))?$/.exec(text);
+    // le premier « : » sépare le projet du lot, un « @ » final le modèle ; le lot garde ses « / » (L120)
+    const m = /^(?:([\w.-]+):)?([\w.-][\w./-]*?)(?:@(\w+))?$/.exec(text);
     if (!m)
         throw new RafError(`lot invalide : ${text} (projet:lot, lot, projet:lot@haiku)`);
     if (m[3] && !MODELS.includes(m[3]))
@@ -56,7 +58,7 @@ function lotArg(text) {
     return { project: m[1], lot: m[2], model: m[3] };
 }
 export function parseOrchestrateArgs(argv) {
-    const a = { lots: [], dryRun: false, answers: [] };
+    const a = { lots: [], dryRun: false, watch: false, answers: [] };
     const optional = (i) => (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-') && !LOT_LIKE.test(argv[i + 1]) ? argv[i + 1] : undefined);
     for (let i = 0; i < argv.length; i++) {
         const t = argv[i];
@@ -73,6 +75,10 @@ export function parseOrchestrateArgs(argv) {
                 i++;
             a[t === '--status' ? 'status' : 'resume'] = v ?? true;
         }
+        else if (t === '--watch')
+            a.watch = true;
+        else if (t === '--interval')
+            a.interval = parseMaxSessions(value(t), '--interval');
         else if (t === '--budget')
             a.budget = parseBudget(value(t));
         else if (t === '--max-sessions')
@@ -256,11 +262,11 @@ function dryRun(lots, io, deps, budget, id) {
         io.out(`  étapes : ${steps.map((s) => `${s.kind} (${s.model})`).join(' → ')}${l.small ? ' — petit lot' : ''}${l.light ? ` — revue légère (${light}, pas de passe des mineurs ; un bloquant ou un majeur → correction puis revue ${full})` : ''}${l.visible && !env.config.ux ? ' — UX à faire par le lead (orchestrate.ux absent)' : ''}`);
         io.out(`  corrections : ${MAX_PASSES} passe(s) au plus, en session neuve`);
         io.out(l.light ? '  revue conforme avec mineurs : pas de passe des mineurs, ils sont rendus en notes' : '  revue conforme avec mineurs : une passe de correction des mineurs (session neuve), puis une revue courte ; les mineurs refusés sont rendus en « choix »');
-        const pwDir = join(resolve(RunStore.runsDir(io.cwd)), id, `${l.project}--${l.lot}`, 'playwright');
+        const pwDir = join(resolve(RunStore.runsDir(io.cwd)), id, lotSlug(l.project, l.lot), 'playwright');
         // brief écrit par --dry-run = base d'une délégation à la main : aucun dossier de vague (il n'existe pas)
         const vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', ux: '', choix: '', checks: '', news: l.visible ? newsText(l.lot) : '', captures: '' };
         for (const s of steps) {
-            const file = join(tmp, `${l.project}--${l.lot}--${s.kind}.md`);
+            const file = join(tmp, `${lotSlug(l.project, l.lot)}--${s.kind}.md`);
             const brief = renderBrief(s.kind, vars, deps.templatesDir);
             writeFileSync(file, brief);
             const playwright = !!mcpServersFor(s.kind, l.visible, '', l.small).playwright;
@@ -268,7 +274,7 @@ function dryRun(lots, io, deps, budget, id) {
             io.out(`  ${s.kind} : claude ${args.join(' ')}`);
             io.out(`    brief : ${file}`);
             const servers = Object.keys(mcpServersFor(s.kind, l.visible, '', l.small));
-            io.out(`    mcp : ${servers.length ? `${servers.join(', ')} (captures dans le dossier de la vague : <vague>/${l.project}--${l.lot}/playwright)` : 'aucun'}`);
+            io.out(`    mcp : ${servers.length ? `${servers.join(', ')} (captures dans le dossier de la vague : <vague>/${lotSlug(l.project, l.lot)}/playwright)` : 'aucun'}`);
         }
     }
 }
@@ -294,6 +300,21 @@ function liveLines() {
         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;
 }
+/** Efface l'écran et replace le curseur en haut : l'entrée d'un rendu de `--status --watch`. */
+const CLEAR_SCREEN = '\x1b[H\x1b[2J';
+const DEFAULT_WATCH_INTERVAL = 10;
+/** Ce que `--status` montre à un instant : les vagues vivantes, puis le tableau (absent si seules les vagues vivantes comptent). */
+function statusView(args, launch) {
+    const store = typeof args.status === 'string' ? RunStore.find(launch, args.status) : RunStore.last(launch);
+    const live = liveLines();
+    if (!store && live.length && args.status === true)
+        return { live, running: true };
+    if (!store)
+        throw new RafError(typeof args.status === 'string' ? `vague inconnue : ${args.status}` : 'aucune vague dans ce dossier');
+    // `running` : la vague suivie tourne — pour un <id> explicite, elle seule compte, pas les autres vagues de la machine
+    const running = typeof args.status === 'string' ? liveWaves(cadenceHome()).some((w) => w.wave === store.readWave().id) : live.length > 0;
+    return { live, table: renderTable(store.readWave(), store.lots()), running };
+}
 /** Refus d'une `--wave` déjà existante, identique en simulation et au vrai lancement. */
 function waveExists(wave, io) {
     io.err(`orchestrate : --wave ${wave} : cette vague existe déjà`);
@@ -304,26 +325,48 @@ export async function orchestrate(argv, io, 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());
+    if (args.watch && args.status === undefined)
+        throw new RafError('--watch s\'utilise avec --status');
+    if (args.interval !== undefined && !args.watch)
+        throw new RafError('--interval s\'utilise avec --status --watch');
     if (args.status !== undefined) {
-        const store = typeof args.status === 'string' ? RunStore.find(launch, args.status) : RunStore.last(launch);
         maxSessions(args, io); // une valeur invalide est refusée ici aussi
-        const live = liveLines();
-        for (const line of live)
-            io.out(line);
-        if (!store && live.length && args.status === true)
-            return 0; // sans identifiant : les vagues vivantes suffisent
-        if (!store)
-            throw new RafError(typeof args.status === 'string' ? `vague inconnue : ${args.status}` : 'aucune vague dans ce dossier');
-        if (live.length)
+        if (!args.watch) {
+            const { live, table } = statusView(args, launch);
+            for (const line of live)
+                io.out(line);
+            if (!table)
+                return 0; // sans identifiant : les vagues vivantes suffisent
+            if (live.length)
+                io.out('');
+            for (const line of table)
+                io.out(line);
+            return 0;
+        }
+        // --watch : le même tableau, rafraîchi ; il s'arrête seul quand plus aucune vague ne tourne (le dernier rendu reste affiché)
+        const sleep = deps.watchSleep ?? ((ms) => new Promise((res) => setTimeout(res, ms)));
+        for (;;) {
+            const { live, table, running } = statusView(args, launch);
+            io.out(CLEAR_SCREEN);
+            for (const line of live)
+                io.out(line);
+            if (table) {
+                if (live.length)
+                    io.out('');
+                for (const line of table)
+                    io.out(line);
+            }
+            if (!running)
+                return 0;
             io.out('');
-        for (const line of renderTable(store.readWave(), store.lots()))
-            io.out(line);
-        return 0;
+            io.out(`rafraîchi toutes les ${args.interval ?? DEFAULT_WATCH_INTERVAL} s — Ctrl-C pour quitter`);
+            await sleep((args.interval ?? DEFAULT_WATCH_INTERVAL) * 1000);
+        }
     }
     if (args.resume !== undefined)
         return resume(args, argv, io, deps, launch, today);
     if (args.lots.length === 0)
-        throw new RafError('usage : cadence orchestrate <projet>:<lot>… [--budget 2M] [--max-sessions 2] [--dry-run] | --status [vague] | --resume [vague] [--answer projet:lot "réponse"]');
+        throw new RafError('usage : cadence orchestrate <projet>:<lot>… [--budget 2M] [--max-sessions 2] [--dry-run] | --status [vague] [--watch [--interval 10]] | --resume [vague] [--answer projet:lot "réponse"]');
     const refusals = [];
     const targets = resolveTargets(args, io, refusals);
     const pre = await preflight(args, targets, io, deps, launch);

package/dist/orchestrate/state.js

@@ -5,7 +5,9 @@ export function newLot(o) {
     return { ...o, status: 'queued', pass: 0, next: null, steps: [], constats: [], verdict: null, uxVerdict: null, questions: [], choix: [], answers: [], proposals: [], warnings: [], outcome: null };
 }
 export const lotKey = (project, lot) => `${project}:${lot}`;
-const lotFile = (project, lot) => `${project}--${lot}.json`;
+/** Nom de dossier d'un lot dans la vague : le « / » d'un id de sous-tâche (`Q4/accueil-4-ux12`) devient « __ » ; un id sans « / » est inchangé. */
+export const lotSlug = (project, lot) => `${project}--${lot.split('/').join('__')}`;
+const lotFile = (project, lot) => `${lotSlug(project, lot)}.json`;
 function atomicWrite(file, data) {
     const tmp = `${file}.${process.pid}.tmp`;
     writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`);
@@ -64,7 +66,7 @@ export class RunStore {
         return existsSync(join(RunStore.runsDir(launchDir), id, 'wave.json')) ? new RunStore(launchDir, id) : null;
     }
     lotDir(project, lot) {
-        const d = join(this.dir, `${project}--${lot}`);
+        const d = join(this.dir, lotSlug(project, lot));
         mkdirSync(d, { recursive: true });
         return d;
     }

package/dist/plan.js

@@ -51,6 +51,13 @@ export class Plan {
     }
     /** Un plan lu dans un autre format ne change pas : sa lecture et le motif de ses références sont gardés. */
     foreign;
+    /**
+     * Un plan en lecture seule dont `fields` ne déclare pas de champ `public` n'a pas de titre public à poser ni à lire,
+     * sauf si l'outil écrit déjà la clé `public` sous son propre nom sur un lot.
+     */
+    get hasPublicField() {
+        return !this.settings.format || !!this.settings.format.fields.public || this.read().lots.some((l) => l.public !== undefined);
+    }
     get readonly() {
         return !!this.settings.format;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylad/cadence",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "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

@@ -55,12 +55,27 @@ proposed sub-tasks back to the human.
 ### 2b. A wave through `cadence orchestrate`
 
 Once the human has chosen the lots, the lead runs, **in the background** (it is notified at the end; no
-silent wait, no polling loop — `cadence orchestrate --status` shows where the wave is):
+silent wait, no polling loop — `cadence orchestrate --status` shows where the wave is, and the follow-up below pushes each transition):
 
 ```sh
-cadence orchestrate <project>:<lot> <project>:<lot>@haiku … [--budget 2M]
+cadence orchestrate <project>:<lot> <project>:<lot>@haiku … --wave <id> [--budget 2M]
 ```
 
+**Make the wave visible to the human.** Name the background task after what it runs — « vague `<id>` :
+`<project>:<lot>`, … » (its `description`), so the task list says which projects and lots, not just « a task
+is running » — and pass `--wave <id>` (e.g. `2026-10-08-1030`) so its state folder is known in advance. Right after
+starting it, arm **one follow-up** (the Monitor tool) on the wave's journal, which holds one line per transition (lot → new
+state, question, ready, handed back). The final table is not in the journal: it arrives with the background task's end notification, at which point stop the follow-up (it never ends by itself; a later `--resume` writes to the same journal):
+
+```sh
+tail -n +1 -F .cadence/runs/<id>/journal.log     # from the folder the wave was launched in
+```
+
+Each line it prints reaches this conversation as it happens: relay it to the human in one short sentence, and
+bring a question back at once (`--resume --answer`). That follow-up replaces any waiting loop: still no polling,
+no `sleep`. The human can also watch from a terminal with `cadence orchestrate --status --watch` (table refreshed
+every 10 s, `--interval <s>` to change it; it stops by itself when no wave is running).
+
 `cadence orchestrate --dry-run …` first when a precondition is in doubt. The program, not the lead, runs
 for each lot a fresh short session per step — implementation (Sonnet), UX review if the lot is `visible`
 and the project declares how to see its app (`orchestrate.ux` in `cadence.yaml`), code review last

package/templates/orchestrate/fix-minors.md

@@ -22,4 +22,4 @@ You are one short session of an orchestrated wave: do not launch subagents (the
 Give your final report as the structured output (commits, tests, build, what you could not verify, choices).
 {{reponse}}
 {{captures}}
-Browser (Playwright): if a Playwright MCP server is available in this session, it was launched by the orchestrator with its own output directory, in the orchestrator's run directory outside the repository: give screenshots, snapshots and traces a relative file name only (e.g. `page-home.png`), they land there. Never an absolute path, never the `--output-dir` option (the server's launch argument, which a session cannot set). If no such server is available, do not install or start one; if you use the Playwright CLI, write its outputs under the OS temp directory (or the temporary folder the project's CLAUDE.md names), never inside the repository, which must stay clean.
+Browser (Playwright): if a Playwright MCP server is available in this session (only in an orchestrated wave: a brief delegated by hand has none), the orchestrator launched it with its own output directory, in the orchestrator's run directory outside the repository: give screenshots, snapshots and traces a relative file name only (e.g. `page-home.png`), they land there. Never an absolute path, never the `--output-dir` option (the server's launch argument, which a session cannot set). If no such server is available, do not install or start one; if you use the Playwright CLI, write its outputs under the OS temp directory (or the temporary folder the project's CLAUDE.md names), never inside the repository, which must stay clean.

package/templates/orchestrate/fix.md

@@ -22,4 +22,4 @@ You are one short session of an orchestrated wave: do not launch subagents (the
 Give your final report as the structured output (commits, tests, build, what you could not verify, choices, questions).
 {{reponse}}
 {{captures}}
-Browser (Playwright): if a Playwright MCP server is available in this session, it was launched by the orchestrator with its own output directory, in the orchestrator's run directory outside the repository: give screenshots, snapshots and traces a relative file name only (e.g. `page-home.png`), they land there. Never an absolute path, never the `--output-dir` option (the server's launch argument, which a session cannot set). If no such server is available, do not install or start one; if you use the Playwright CLI, write its outputs under the OS temp directory (or the temporary folder the project's CLAUDE.md names), never inside the repository, which must stay clean.
+Browser (Playwright): if a Playwright MCP server is available in this session (only in an orchestrated wave: a brief delegated by hand has none), the orchestrator launched it with its own output directory, in the orchestrator's run directory outside the repository: give screenshots, snapshots and traces a relative file name only (e.g. `page-home.png`), they land there. Never an absolute path, never the `--output-dir` option (the server's launch argument, which a session cannot set). If no such server is available, do not install or start one; if you use the Playwright CLI, write its outputs under the OS temp directory (or the temporary folder the project's CLAUDE.md names), never inside the repository, which must stay clean.

package/templates/orchestrate/implement.md

@@ -26,4 +26,4 @@ Give your final report as the structured output, not as free text. If the plan i
 {{news}}
 {{commits}}
 {{reponse}}
-Browser (Playwright): if a Playwright MCP server is available in this session, it was launched by the orchestrator with its own output directory, in the orchestrator's run directory outside the repository: give screenshots, snapshots and traces a relative file name only (e.g. `page-home.png`), they land there. Never an absolute path, never the `--output-dir` option (the server's launch argument, which a session cannot set). If no such server is available, do not install or start one; if you use the Playwright CLI, write its outputs under the OS temp directory (or the temporary folder the project's CLAUDE.md names), never inside the repository, which must stay clean.
+Browser (Playwright): if a Playwright MCP server is available in this session (only in an orchestrated wave: a brief delegated by hand has none), the orchestrator launched it with its own output directory, in the orchestrator's run directory outside the repository: give screenshots, snapshots and traces a relative file name only (e.g. `page-home.png`), they land there. Never an absolute path, never the `--output-dir` option (the server's launch argument, which a session cannot set). If no such server is available, do not install or start one; if you use the Playwright CLI, write its outputs under the OS temp directory (or the temporary folder the project's CLAUDE.md names), never inside the repository, which must stay clean.

package/templates/orchestrate/review-small.md

@@ -11,4 +11,4 @@ Give your report as the structured output: counts of blocking / major / minor fi
 findings included, each tied to a named rule — Nielsen heuristic or WCAG 2.2 AA criterion — or a
 measurement), each finding (severity, file, line, text), proposed sub-tasks, what you could not
 verify, and the one-line verdict for `raf review {{lot}}`.
-Browser (Playwright): if a Playwright MCP server is available in this session, it was launched by the orchestrator with its own output directory, in the orchestrator's run directory outside the repository: give screenshots, snapshots and traces a relative file name only (e.g. `page-home.png`), they land there. Never an absolute path, never the `--output-dir` option (the server's launch argument, which a session cannot set). If no such server is available, do not install or start one; if you use the Playwright CLI, write its outputs under the OS temp directory (or the temporary folder the project's CLAUDE.md names), never inside the repository, which must stay clean.
+Browser (Playwright): if a Playwright MCP server is available in this session (only in an orchestrated wave: a brief delegated by hand has none), the orchestrator launched it with its own output directory, in the orchestrator's run directory outside the repository: give screenshots, snapshots and traces a relative file name only (e.g. `page-home.png`), they land there. Never an absolute path, never the `--output-dir` option (the server's launch argument, which a session cannot set). If no such server is available, do not install or start one; if you use the Playwright CLI, write its outputs under the OS temp directory (or the temporary folder the project's CLAUDE.md names), never inside the repository, which must stay clean.