@sylad/cadence 0.10.1 → 0.12.0

package/dist/orchestrate/cycle.js

@@ -1,16 +1,18 @@
 import { execFileSync, spawn } from 'node:child_process';
+import { toolBinOf, withoutLaunchVars } from './snapshot.js';
 import { randomUUID } from 'node:crypto';
-import { join, relative } from 'node:path';
+import { dirname, join, relative } from 'node:path';
 import { writeFileSync } from 'node:fs';
 import { lotCommits, lotWork } from '../audit.js';
 import { readCommits, resolveCommit } from '../git.js';
 import { citedRefs } from '../link.js';
 import { isOpen } from '../plan.js';
 import { isPlanOnly } from '../audit.js';
-import { objective, renderBrief } from './briefs.js';
-import { journalTokens, peakContext, runSession, trackGroup } from './launch.js';
-import { pushed, snapshot } from './guard.js';
-import { checkShape, REVIEW_SCHEMA, schemaFor, WORK_SCHEMA } from './schemas.js';
+import { APP_TIMEOUT_S, startApp } from './app.js';
+import { capturesText, newsText, objective, renderBrief } from './briefs.js';
+import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, trackGroup, writeMcpConfig } from './launch.js';
+import { cleanPlaywrightOutput, pushed, snapshot } from './guard.js';
+import { checkShape, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, WORK_SCHEMA } from './schemas.js';
 import { lotKey } from './state.js';
 /** Passes de correction au plus, puis la main est rendue au lead. */
 export const MAX_PASSES = 2;
@@ -87,7 +89,7 @@ const shEscape = (s) => s.replace(/\s+/g, ' ').replace(/[\\"$`]/g, '\\$&');
 /** Commande du projet, asynchrone : la boucle d'événements reste libre (délai de l'autre créneau, signaux). Son groupe est tué au délai et au signal. */
 function sh(c, command, timeoutMs = 30 * 60_000) {
     return new Promise((resolve) => {
-        const child = spawn('sh', ['-c', command], { cwd: c.lot.repo, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
+        const child = spawn('sh', ['-c', command], { cwd: c.lot.repo, env: withoutLaunchVars(process.env), stdio: ['ignore', 'pipe', 'pipe'], detached: true });
         const pid = child.pid;
         if (pid === undefined) {
             child.once('error', (e) => resolve({ code: 127, output: String(e.message) }));
@@ -157,15 +159,21 @@ function constatLines(constats) {
         .map((k) => `- [${k.gravite}${k.source === 'code' ? '' : ` / ${k.source}`}] ${k.fichier ? `${k.fichier}${k.ligne ? `:${k.ligne}` : ''} — ` : ''}${k.texte}`)
         .join('\n');
 }
+/** Consigne de captures : `uxText` n'alimente que `ux` et `review-small` d'un petit lot visible, deux étapes qui chargent toujours le serveur Playwright de la vague. */
+const SHOTS_TEXT = 'Take screenshots at 1440 and 390 px width, each with a relative file name only (e.g. `home-1440px.png`): they land in the wave\'s capture directory, outside the repository.';
 function uxText(c) {
     const ux = c.config.ux;
     if (!ux) {
         return 'No way to run the app is declared (cadence.yaml: orchestrate.ux): review the interface from the code, and list under "nonVerifie" what you could not see.';
     }
+    if (c.app?.kind === 'ready')
+        return [`The running app is at ${ux.url}.`, SHOTS_TEXT].join(' ');
+    if (c.app)
+        return `The app could not be verified (${c.app.kind === 'busy' ? 'the port is already in use' : 'it did not start'}): review the interface from the code, and list under "nonVerifie" what you could not see.`;
     return [
         ux.url ? `The running app is at ${ux.url}.` : '',
         ux.command ? `Start the app with: ${ux.command} (from the repository root), and stop it when you are done.` : '',
-        'Take screenshots at 1440 and 390 px width (into the shared tmp folder, never in the repository).',
+        SHOTS_TEXT,
     ]
         .filter(Boolean)
         .join(' ');
@@ -175,6 +183,14 @@ function choixText(choix) {
         return '';
     return ['The author decided these interpretation questions on its own; re-read each choice against the lot, its notes and the code, and report a finding if one is wrong or changes the scope:', ...choix.map((x) => `- ${x}`)].join('\n');
 }
+/** Tests et build déjà lancés par le programme au HEAD relu : le relecteur ne les refait pas (L75). Vide si HEAD a bougé depuis ou si rien n'a tourné. */
+function checksText(c) {
+    const k = c.lot.checks;
+    if (!k?.runs.length || k.head !== git(c.lot.repo, 'rev-parse', 'HEAD'))
+        return '';
+    const runs = k.runs.map((r) => `- \`${r.command}\` (${r.label}): ${r.code === 0 ? 'green' : `RED, exit code ${r.code}`}`);
+    return [`The program already ran these checks at HEAD ${k.head.slice(0, 7)}, just before this review:`, ...runs, 'Take these results as given: do not rebuild, do not rerun the whole suite, and do not wait on them. Run only a check they do not cover (a targeted test of a case you doubt), and list under "nonVerifie" what neither they nor you verified.'].join('\n');
+}
 /** Gabarit d'une étape : la passe des mineurs et la revue courte qui la suit ont chacune le leur. */
 function briefName(l, kind) {
     if (kind === 'fix' && l.minorFix)
@@ -187,7 +203,12 @@ function briefFor(c, kind) {
     const plan = c.loadPlan();
     const l = c.lot;
     const lot = plan.lot(l.lot);
-    const vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []) };
+    const vars = { chemin: l.repo, lot: l.lot, titre: lot.title, objectif: objective(lot), commits: '', reponse: '', constats: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', news: '', captures: '' };
+    if (l.visible) {
+        const pwDir = playwrightDir(c.wave.store.lotDir(l.project, l.lot));
+        vars.news = newsText(l.lot, pwDir);
+        vars.captures = capturesText(pwDir);
+    }
     if (kind === 'implement' || kind === 'fix') {
         const interrupted = [...l.steps].reverse().find((s) => s.kind === kind && s.status === 'interrupted');
         if (kind === 'fix') {
@@ -200,11 +221,17 @@ function briefFor(c, kind) {
                 ? `A previous session was interrupted; resume from these commits of the lot already present:\n${mine}`
                 : 'A previous session was interrupted before any commit of the lot; start again from the current state of the repository.';
         }
+        if (kind === 'implement' && l.precheck)
+            vars.commits = [vars.commits, l.precheck].filter(Boolean).join('\n');
         if (l.pendingAnswer)
             vars.reponse = `Answer from the human to your earlier question: ${l.pendingAnswer}`;
     }
     return renderBrief(briefName(l, kind), vars, c.wave.templates);
 }
+/** Tokens comptés par les sessions d'un lot (un lot repris compte ses étapes d'avant). */
+export const lotSpent = (l) => l.steps.reduce((n, s) => n + (s.tokens?.counted ?? 0), 0);
+/** Le lot a dépensé son propre budget (L78) : il ne compte plus que sur le lead, la vague garde le sien pour les autres. */
+const lotOver = (l) => l.budget !== undefined && lotSpent(l) >= l.budget;
 /** Pourquoi plus aucune session ne doit partir (incident, quota, budget), sinon null. */
 function halted(w) {
     if (w.incident)
@@ -215,6 +242,11 @@ function halted(w) {
         return 'budget atteint';
     return null;
 }
+/** Modèle d'une revue (L108) : la revue légère d'un lot léger tant qu'aucune correction n'a eu lieu, sinon la revue complète (UX comprise). */
+function reviewModel(c, kind) {
+    const { light, full } = c.config.review;
+    return c.lot.light && c.lot.pass === 0 && (kind === 'review' || kind === 'review-small') ? light : full;
+}
 /** Une session : budget et quota vérifiés avant, état écrit avant et après, journal gardé, contrôles du dépôt après. */
 async function session(c, kind) {
     const w = c.wave;
@@ -222,14 +254,16 @@ async function session(c, kind) {
     const halt = halted(w);
     if (halt)
         return suspend(c, halt);
+    if (lotOver(l))
+        return overBudget(c);
     const write = kind === 'implement' || kind === 'fix';
-    const model = write ? l.model : 'opus';
+    const model = write ? l.model : kind === 'precheck' ? 'sonnet' : reviewModel(c, kind); // le contrôle préalable ne fait que lire : pas d'Opus
     const before = await snapshot(l.repo);
     const n = l.steps.length + 1;
     const sessionId = randomUUID();
     const step = { n, kind, model, status: 'running', sessionId, started: new Date().toISOString(), headBefore: before.head ?? undefined };
     l.steps.push(step);
-    const label = { implement: 'implementing', fix: 'fixing', review: 'reviewing', ux: 'reviewing', 'review-small': 'reviewing' };
+    const label = { implement: 'implementing', fix: 'fixing', review: 'reviewing', ux: 'reviewing', 'review-small': 'reviewing', precheck: 'implementing' };
     transition(c, label[kind]);
     w.log(`${lotKey(l.project, l.lot)} · session ${n} ${kind} (${model})`);
     let brief;
@@ -241,6 +275,10 @@ async function session(c, kind) {
         step.cause = e.message;
         return stop(c, 'failed', `brief de ${kind} : ${e.message}`);
     }
+    const mcpConfig = writeMcpConfig(w.store.lotDir(l.project, l.lot), kind, l.visible, l.small);
+    const playwright = !!mcpServersFor(kind, l.visible, '', l.small).playwright;
+    if (playwright)
+        l.uxCaptures = join(dirname(mcpConfig), 'playwright');
     l.pendingAnswer = null; // la réponse est dans le brief : elle ne repart pas avec la session suivante
     const outcome = await runSession({
         kind,
@@ -248,11 +286,15 @@ async function session(c, kind) {
         brief,
         model,
         schema: schemaFor(kind),
-        agent: kind === 'ux' ? 'ux-reviewer' : write ? undefined : 'code-reviewer',
+        agent: kind === 'ux' ? 'ux-reviewer' : kind === 'precheck' ? 'precheck-reader' : write ? undefined : 'code-reviewer',
         cwd: l.repo,
         wave: w.id,
         permissionMode: c.config.permissionMode,
-        addDirs: c.config.addDirs,
+        addDirs: playwright && write ? [...c.config.addDirs, playwrightDir(dirname(mcpConfig))] : c.config.addDirs,
+        nodeBin: l.node?.link,
+        toolBin: toolBinOf(w.store.dir),
+        mcpConfig,
+        playwright,
         timeoutMs: write ? c.config.timeouts.work : c.config.timeouts.review,
     }, {
         claude: w.claude,
@@ -341,6 +383,13 @@ async function session(c, kind) {
     save(c);
     return { step, report: res.structured, before, after };
 }
+/** Budget du lot atteint avant une session : le lot est rendu au lead (reprendre ne lui rendrait pas de budget), les autres continuent. */
+function overBudget(c) {
+    const l = c.lot;
+    // Une réponse du lead encore en attente n'a pas été consommée : elle ne doit pas se perdre sans qu'on le dise.
+    const answer = l.pendingAnswer ? ` ; la réponse du lead (« ${l.pendingAnswer} ») n'a pas été jouée` : '';
+    return stop(c, 'handed-back', `budget du lot atteint (${lotSpent(l)} / ${l.budget} tokens comptés, dérivé de l'estimate) : étape « ${l.next ?? '?'} » non jouée${answer}, à décider par le lead`);
+}
 function suspend(c, why) {
     transition(c, 'suspended', why);
     return null;
@@ -376,6 +425,46 @@ function badReport(c, step, e) {
     step.cause = e.message;
     return stop(c, 'failed', `${step.kind} : ${e.message}`);
 }
+/** Le contrôle préalable ne vaut que pour un lot sans commit : avec des commits, l'implémentation reprend légitimement. */
+export function needsPrecheck(config, plan, repo, lot) {
+    return config.precheck && lotWork(plan, repo, lot).length === 0;
+}
+/**
+ * Contrôle préalable (L77) : une session de lecture seule cherche si le livrable du lot est déjà dans le dépôt (fait par un
+ * autre lot). « oui » rend le lot sans ouvrir d'implémentation ; « partiel » joint le constat au brief de l'implémentation.
+ * Un rapport illisible ne bloque pas : avertissement, l'implémentation part.
+ */
+async function precheck(c) {
+    const l = c.lot;
+    const done = await session(c, 'precheck');
+    if (!done)
+        return;
+    let rep;
+    try {
+        rep = checkShape(done.report, PRECHECK_SCHEMA);
+    }
+    catch (e) {
+        l.warnings.push(`contrôle préalable illisible, implémentation lancée : ${e.message}`);
+        l.next = 'implement';
+        save(c);
+        return;
+    }
+    const proofs = rep.preuves.length ? ` (${rep.preuves.join(' ; ')})` : '';
+    // « oui » sans preuve ne se vérifie pas : il vaut « partiel », l'implémentation part avec le constat.
+    const unproven = rep.dejaPresent === 'oui' && rep.preuves.length === 0;
+    if (unproven)
+        l.warnings.push('contrôle préalable : « oui » sans preuve, traité comme partiel');
+    if (rep.dejaPresent === 'oui' && !unproven) {
+        stop(c, 'handed-back', `livrable déjà présent : ${rep.resume.trim()}${proofs}`);
+        return;
+    }
+    if (rep.dejaPresent === 'partiel' || unproven) {
+        l.precheck = `A pre-check found part of the deliverable already in the repository (do not redo it): ${rep.resume.trim()}${proofs}`;
+        l.warnings.push(`contrôle préalable : livrable en partie présent — ${rep.resume.trim()}${proofs}`);
+    }
+    l.next = 'implement';
+    save(c);
+}
 /** Étape d'écriture (implémentation, correction) : contrôles, puis étape suivante décidée. */
 async function work(c, kind) {
     const l = c.lot;
@@ -419,13 +508,18 @@ async function work(c, kind) {
             l.choix.push(x);
     save(c);
     // La passe des mineurs ne bloque jamais le lot (revue conforme déjà acquise) : une question est rendue en proposition.
+    const questions = rep.questions.filter((q) => !isNonQuestion(q));
+    // Une entrée filtrée reste visible (avertissement du lot, donc tableau de fin de vague) ; l'entrée vide n'a rien à montrer.
+    for (const q of rep.questions)
+        if (q.trim() && isNonQuestion(q))
+            l.warnings.push(`question ignorée (non-question) : « ${q.trim()} »`);
     if (minorsPass)
-        for (const q of rep.questions)
+        for (const q of questions)
             propose(c, `[question passe des mineurs] ${q}`);
-    if (!minorsPass && rep.questions.length) {
-        l.questions = rep.questions;
+    if (!minorsPass && questions.length) {
+        l.questions = questions;
         l.next = kind;
-        transition(c, 'question', rep.questions[0]);
+        transition(c, 'question', questions[0]);
         return;
     }
     const dirt = [...trackedPaths(done.after), ...done.after.untracked.filter((f) => !done.before.untracked.includes(f))];
@@ -456,7 +550,7 @@ async function work(c, kind) {
     }
     // La session peut n'avoir plus rien à commiter (réponse du lead, lot commité avant la vague) : le travail du lot est déjà dans git.
     // Même règle côté fix (L56) : la passe n'avait rien à ajouter, le lot a déjà ses commits de travail → revue neuve ; la passe reste consommée, MAX_PASSES borne la boucle.
-    const alreadyDone = (kind === 'implement' || kind === 'fix') && lotWork(plan, l.repo, l.lot).length > 0;
+    const alreadyDone = lotWork(plan, l.repo, l.lot).length > 0;
     if (commits.length === 0 && !alreadyDone && !headMoved) {
         stop(c, 'handed-back', `${kind} sans commit`);
         return;
@@ -470,16 +564,25 @@ async function work(c, kind) {
         red.push({ source: 'tests', gravite: 'bloquant', texte: `tests annoncés rouges par la session : ${rep.tests.commande} — ${rep.tests.resultat}` });
     if (!rep.build.vert)
         red.push({ source: 'tests', gravite: 'bloquant', texte: `build annoncé rouge par la session : ${rep.build.commande} — ${rep.build.resultat}` });
-    if (red.length === 0 && c.config.test) {
-        const r = await sh(c, c.config.test);
-        if (r.code !== 0)
-            red.push({ source: 'tests', gravite: 'bloquant', texte: `${c.config.test} en échec (code ${r.code}) :\n${r.output.trim().split('\n').slice(-40).join('\n')}` });
+    const runs = [];
+    if (red.length === 0) {
+        for (const [label, command] of [['tests', c.config.test], ['build', c.config.build]]) {
+            if (!command)
+                continue;
+            const r = await sh(c, command);
+            runs.push({ label, command, code: r.code });
+            if (r.code !== 0) {
+                red.push({ source: 'tests', gravite: 'bloquant', texte: `${command} en échec (code ${r.code}) :\n${r.output.trim().split('\n').slice(-40).join('\n')}` });
+                break;
+            }
+        }
     }
     if (red.length) {
         toFix(c, red, 'tests rouges');
         return;
     }
     l.constats = [];
+    l.checks = runs.length ? { head: git(l.repo, 'rev-parse', 'HEAD'), runs } : undefined;
     l.next = firstReview(c);
     save(c);
 }
@@ -514,7 +617,55 @@ function toFix(c, constats, what) {
     l.next = 'fix';
     save(c);
 }
+/** Les deux étapes qui voient l'application : la revue UX, et la passe unique d'un petit lot visible. */
+const seesApp = (l, kind) => kind === 'ux' || (kind === 'review-small' && l.small && l.visible);
+const appNote = (state, ux) => state.kind === 'busy' ? `UX non vérifiée : port occupé (${ux.url} répond déjà, l'application n'a pas été lancée)` : state.kind === 'unverified' ? `UX non vérifiée : ${state.cause}` : '';
+/**
+ * Avec `command` ET `url`, le programme lance l'application avant l'étape et la tue après (succès, erreur ou signal) :
+ * port occupé ou application muette, la revue UX n'a pas lieu (note dans le lot, la revue de code suit) ; la passe
+ * unique d'un petit lot, elle, a lieu sur le code seul.
+ */
 async function review(c, kind) {
+    const l = c.lot;
+    const ux = c.config.ux;
+    if (!ux?.command || !ux.url || !seesApp(l, kind))
+        return reviewStep(c, kind);
+    const halt = halted(c.wave);
+    if (halt) {
+        suspend(c, halt); // la session n'aurait pas lieu : l'application ne se lance pas pour rien
+        return;
+    }
+    if (lotOver(l)) {
+        overBudget(c);
+        return;
+    }
+    c.wave.log(`${lotKey(l.project, l.lot)} · lancement de l'application (${ux.url})`);
+    const app = await startApp({ command: ux.command, url: ux.url, cwd: l.repo, nodeBin: l.node?.link, log: join(c.wave.store.lotDir(l.project, l.lot), 'ux-app.log'), timeoutMs: (ux.timeout ?? APP_TIMEOUT_S) * 1000 });
+    try {
+        c.app = app.state;
+        if (app.state.kind !== 'ready') {
+            l.uxNote = appNote(app.state, ux);
+            c.wave.log(`${lotKey(l.project, l.lot)} · ${l.uxNote.split('\n')[0]}`);
+            if (kind === 'ux') {
+                // Aucune session : une revue UX antérieure, périmée par le code qui a changé, ne pèse plus.
+                l.ux = undefined;
+                l.uxVerdict = null;
+                l.constats = l.constats.filter((k) => k.source !== 'ux');
+                l.next = codeReview(l);
+                save(c);
+                return;
+            }
+        }
+        else if (l.uxNote?.startsWith('UX non vérifiée'))
+            l.uxNote = undefined;
+        await reviewStep(c, kind);
+    }
+    finally {
+        c.app = undefined;
+        await app.stop();
+    }
+}
+async function reviewStep(c, kind) {
     const l = c.lot;
     const done = await session(c, kind);
     if (!done)
@@ -548,11 +699,11 @@ async function review(c, kind) {
     const minors = minorConstats(rep);
     // Revue conforme avec mineurs : une seule passe de correction des mineurs, avant de conclure (rien sous le tapis).
     // Budget épuisé : la passe n'aurait aucune session pour la jouer, le lot conclut sur la revue conforme et rend les mineurs.
-    const wanted = summary.conforme && uxOk && !l.minorPass && minors.length > 0;
-    const noBudget = wanted && w.budget.exhausted && !w.incident && !w.quota.hit;
+    const wanted = summary.conforme && uxOk && !l.minorPass && !l.light && minors.length > 0; // lot léger : les mineurs restent des notes (L108)
+    const noBudget = wanted && (w.budget.exhausted || lotOver(l)) && !w.incident && !w.quota.hit;
     const minorPass = wanted && !noBudget;
     if (noBudget)
-        l.warnings.push('budget atteint : la passe des mineurs n\'a pas eu lieu, mineurs rendus en propositions');
+        l.warnings.push(`${w.budget.exhausted ? 'budget' : 'budget du lot'} atteint : la passe des mineurs n'a pas eu lieu, mineurs rendus en propositions`);
     // Les mineurs confiés à la passe ont pu être proposés par une revue non conforme antérieure : si la revue qui la suit est
     // conforme, ils sont traités et ne restent pas en propositions (ceux que cette revue signale encore sont ajoutés juste après).
     if (l.minorPass && !minorPass && summary.conforme && uxOk && l.minorLines?.length) {
@@ -628,6 +779,26 @@ async function conclude(c, code, minorNote = '') {
     l.next = null;
     transition(c, 'ready', 'prêt à livrer');
 }
+/** Formes connues de « pas de question » : l'entrée entière, normalisée, doit en égaler une (liste fermée, L52). */
+const NON_QUESTIONS = new Set([
+    '', 'vide', '(vide)', 'n/a', 'na', 'none', 'nothing', 'nil', 'rien', 'néant', 'neant', 'aucune', 'aucun',
+    'aucune question', 'aucune autre question', 'aucune question bloquante', 'aucune question supplémentaire', 'aucune question supplementaire',
+    'pas de question', 'pas de questions', 'pas de question bloquante', 'pas de questions bloquantes', 'plus de question', 'plus de questions',
+    "je n'ai pas de question", "je n'ai pas de questions", "je n'ai aucune question", "je n'ai pas de question bloquante", "je n'ai pas de questions bloquantes", "je n'ai aucune question bloquante",
+    'no question', 'no questions', 'no open question', 'no open questions', 'no blocking question', 'no blocking questions',
+    'no other question', 'no other questions', 'no further question', 'no further questions',
+    'i have no question', 'i have no questions', 'i have no blocking question', 'i have no blocking questions', 'there are no questions', 'there is no question',
+]);
+/** Casse, espaces, ponctuation finale (hors « ? ») et apostrophe typographique ramenés à la forme de comparaison. */
+function normalizeQuestion(q) {
+    return q.trim().toLowerCase().replace(/[’‘]/gu, "'").replace(/\s+/gu, ' ').replace(/[\s.!:;,\-–—…]+$/u, '');
+}
+/** Une « question » vide ou qui dit exactement qu'il n'y en a pas (« aucune question », « no questions », « n/a ») n'arrête pas le lot ; une entrée qui contient « ? » n'est jamais filtrée. */
+export function isNonQuestion(q) {
+    if (q.includes('?'))
+        return false;
+    return NON_QUESTIONS.has(normalizeQuestion(q));
+}
 /** Joue le cycle d'un lot jusqu'à son terme, ou jusqu'à l'arrêt (question, budget, quota). Ne lève jamais. */
 export async function runLot(c) {
     const l = c.lot;
@@ -654,12 +825,14 @@ export async function runLot(c) {
                 return;
             }
             l.startedSha = (await snapshot(l.repo, { remote: false })).head ?? undefined;
-            l.next = 'implement';
+            l.next = needsPrecheck(c.config, c.loadPlan(), l.repo, l.lot) ? 'precheck' : 'implement';
             save(c);
         }
         while (l.next && !TERMINAL.has(l.status)) {
             const kind = l.next;
-            if (kind === 'implement' || kind === 'fix')
+            if (kind === 'precheck')
+                await precheck(c);
+            else if (kind === 'implement' || kind === 'fix')
                 await work(c, kind);
             else
                 await review(c, kind);
@@ -671,4 +844,13 @@ export async function runLot(c) {
         l.next = null;
         transition(c, 'failed', `erreur : ${e.message}`);
     }
+    finally {
+        // Sorties du MCP Playwright qu'une session a écrites dans le dépôt (L50) : jetables, retirées à la fin de chaque passage du lot.
+        try {
+            cleanPlaywrightOutput(l.repo);
+        }
+        catch {
+            // nettoyage de confort : jamais une cause d'échec du lot
+        }
+    }
 }

package/dist/orchestrate/guard.js

@@ -1,5 +1,5 @@
-import { chmodSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { execFile } from 'node:child_process';
+import { chmodSync, existsSync, lstatSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { execFile, execFileSync } from 'node:child_process';
 import { appendFileSync, mkdirSync } from 'node:fs';
 import { dirname, isAbsolute, join, relative } from 'node:path';
 import { gitCommonDir, gitRoot, hooksDir } from '../git.js';
@@ -34,6 +34,66 @@ function excludeLine(repo) {
     return `/${rel.split('\\').join('/')}`;
 }
 const excludeFile = (repo) => join(gitCommonDir(repo), 'info', 'exclude');
+/**
+ * État de `.git/info/exclude` avant la première vague (fichier absent ? sans retour à la ligne final ?), gardé à côté
+ * pour que la fin de vague le restitue à l'octet près. Une reprise garde l'état d'origine déjà noté.
+ */
+const excludeMemo = (repo) => join(gitCommonDir(repo), 'info', 'cadence-exclude-before');
+function rememberExclude(repo) {
+    const memo = excludeMemo(repo);
+    if (existsSync(memo))
+        return;
+    const file = excludeFile(repo);
+    const text = existsSync(file) ? readFileSync(file, 'utf8') : null;
+    const line = excludeLine(repo);
+    const note = {
+        absent: text === null,
+        noFinalNewline: text !== null && text !== '' && !text.endsWith('\n'),
+        content: text ?? '',
+        // Un hook cadence déjà en place = une vague interrompue (0.11.0 sans note) : la ligne est la sienne, pas celle de l'utilisateur (L89).
+        hookLine: line !== null && text !== null && !guardPresent(repo) && text.split('\n').includes(line),
+    };
+    mkdirSync(join(gitCommonDir(repo), 'info'), { recursive: true });
+    writeFileSync(memo, JSON.stringify(note));
+}
+/** La note d'état d'origine, ou null quand elle est absente ou illisible (vide, JSON invalide ou de mauvaise forme) : elle est alors ignorée, jamais une erreur. */
+function readExcludeMemo(repo) {
+    try {
+        const m = JSON.parse(readFileSync(excludeMemo(repo), 'utf8'));
+        if (m === null || typeof m !== 'object' || typeof m.absent !== 'boolean' || typeof m.noFinalNewline !== 'boolean')
+            return null;
+        return { absent: m.absent, noFinalNewline: m.noFinalNewline, content: typeof m.content === 'string' ? m.content : undefined, hookLine: m.hookLine === true };
+    }
+    catch {
+        return null;
+    }
+}
+function restoreExclude(repo) {
+    const memo = excludeMemo(repo);
+    if (!existsSync(memo))
+        return;
+    try {
+        const before = readExcludeMemo(repo);
+        const file = excludeFile(repo);
+        if (before && existsSync(file)) {
+            const text = readFileSync(file, 'utf8');
+            if (before.absent && text === '')
+                rmSync(file, { force: true });
+            else if (before.noFinalNewline && text.endsWith('\n') && !text.includes(PW_MARK)) {
+                // Le saut de ligne n'est retiré que s'il est celui de la vague : une ligne ajoutée par l'utilisateur depuis reste intacte.
+                const ours = before.content === undefined ? true : text === `${before.content}\n`;
+                if (ours)
+                    writeFileSync(file, text.slice(0, -1));
+            }
+        }
+    }
+    catch {
+        // État illisible : on ne casse pas la fin de vague (release() des dépôts suivants).
+    }
+    finally {
+        rmSync(memo, { force: true });
+    }
+}
 function addExclude(repo) {
     const line = excludeLine(repo);
     if (!line)
@@ -50,11 +110,91 @@ function removeExclude(repo) {
     const file = excludeFile(repo);
     if (!line || !existsSync(file))
         return;
+    if (readExcludeMemo(repo)?.hookLine)
+        return; // la ligne était déjà là avant la vague : elle reste
     const lines = readFileSync(file, 'utf8').split('\n');
     if (!lines.includes(line))
         return;
     writeFileSync(file, lines.filter((l) => l !== line).join('\n'));
 }
+/** Sorties du MCP Playwright écrites dans le dépôt par une session qui ne respecte pas son dossier de sortie (L50). */
+const PW_DIR = '.playwright-mcp';
+const PW_PATTERN = `/${PW_DIR}/`;
+const PW_MARK = '# cadence orchestrate — sorties Playwright MCP exclues le temps de la vague';
+/** Exclut `.playwright-mcp/` le temps de la vague ; une exclusion déjà présente n'est ni dupliquée ni retirée ensuite. */
+function addPlaywrightExclude(repo) {
+    const file = excludeFile(repo);
+    mkdirSync(join(gitCommonDir(repo), 'info'), { recursive: true });
+    const text = existsSync(file) ? readFileSync(file, 'utf8') : '';
+    const lines = text.split('\n');
+    if (lines.some((l) => l === PW_PATTERN || l === `${PW_DIR}/` || l === PW_DIR))
+        return;
+    appendFileSync(file, `${text === '' || text.endsWith('\n') ? '' : '\n'}${PW_MARK}\n${PW_PATTERN}\n`);
+}
+function removePlaywrightExclude(repo) {
+    const file = excludeFile(repo);
+    if (!existsSync(file))
+        return;
+    const lines = readFileSync(file, 'utf8').split('\n');
+    const i = lines.indexOf(PW_MARK);
+    if (i < 0 || lines[i + 1] !== PW_PATTERN)
+        return;
+    lines.splice(i, 2);
+    writeFileSync(file, lines.join('\n'));
+}
+/**
+ * Supprime les fichiers NON SUIVIS de `.playwright-mcp/` (jamais un fichier suivi) ; le dossier part quand il est vide.
+ * Jamais de lien suivi : racine ou entrée qui est un lien symbolique n'est pas parcourue (l'entrée est retirée elle-même,
+ * la racine reste), et une racine ou un ancêtre suivi par git n'est pas parcouru (`ls-files` renvoie alors le chemin lui-même).
+ */
+export function cleanPlaywrightOutput(repo) {
+    const root = gitRoot(repo);
+    if (!root)
+        return;
+    const dir = join(root, PW_DIR);
+    let st;
+    try {
+        st = lstatSync(dir);
+    }
+    catch {
+        return;
+    }
+    if (st.isSymbolicLink() || !st.isDirectory())
+        return;
+    let tracked;
+    try {
+        tracked = execFileSync('git', ['ls-files', '-z', '--', PW_DIR], { cwd: root, encoding: 'utf8' }).split('\0').filter(Boolean);
+    }
+    catch {
+        return;
+    }
+    if (tracked.includes(PW_DIR))
+        return;
+    const keeps = (r) => tracked.some((t) => t === r || t.startsWith(`${r}/`) || r.startsWith(`${t}/`));
+    const walk = (d, rel) => {
+        let empty = true;
+        for (const e of readdirSync(d, { withFileTypes: true })) {
+            const r = `${rel}/${e.name}`;
+            const full = join(d, e.name);
+            if (keeps(r)) {
+                // suivi, ou ancêtre d'un suivi : un dossier est parcouru pour ses entrées non suivies, un fichier ou un lien reste
+                if (e.isDirectory() && !tracked.includes(r))
+                    walk(full, r);
+                empty = false;
+            }
+            else if (lstatSync(full).isDirectory()) {
+                if (!walk(full, r))
+                    empty = false;
+            }
+            else
+                rmSync(full, { force: true }); // fichier ou lien : retiré lui-même, jamais suivi
+        }
+        if (empty)
+            rmSync(d, { recursive: true, force: true });
+        return empty;
+    };
+    walk(dir, PW_DIR);
+}
 /**
  * Pose le hook pre-push temporaire. Refus (raison) quand un autre hook pre-push existe : le remplacer
  * modifierait un fichier suivi (husky) ou sauterait une règle du projet. Un hook laissé par une vague
@@ -66,7 +206,9 @@ export function installPrePush(repo, wave = '?') {
         return { ok: false, reason: `un hook pre-push existe déjà (${file}) : l'orchestrateur ne le remplace pas` };
     }
     mkdirSync(dirname(file), { recursive: true });
+    rememberExclude(repo);
     addExclude(repo);
+    addPlaywrightExclude(repo);
     writeFileSync(file, hook(wave));
     chmodSync(file, 0o755);
     return { ok: true };
@@ -87,6 +229,8 @@ export function removePrePush(repo, wave) {
         }
     }
     removeExclude(repo);
+    removePlaywrightExclude(repo);
+    restoreExclude(repo);
 }
 /** Pourrait-on poser le hook ? (préconditions, sans écrire) */
 export function canInstallPrePush(repo) {
@@ -113,7 +257,8 @@ export async function snapshot(repo, opts = {}) {
         opts.remote === false ? Promise.resolve(null) : out(repo, ['ls-remote', '--heads']),
     ]);
     const lines = (status ?? '').split('\n').filter(Boolean);
-    const keep = (l) => !/^.. \.cadence\//.test(l) && !/^\?\? \.cadence\//.test(l);
+    // .cadence/ (état de l'outil) et .playwright-mcp/ (sorties du MCP Playwright, écrites dans le dossier courant, qu'un dépôt déjà initialisé n'ignore pas forcément) ne comptent jamais comme un dépôt sale.
+    const keep = (l) => !/^.. "?(\.cadence|\.playwright-mcp)\//.test(l);
     return {
         head: head?.trim() || null,
         tracked: lines.filter((l) => !l.startsWith('??') && keep(l)),