@sylad/cadence 1.32.0 → 1.34.1

package/dist/orchestrate/cycle.js

@@ -10,6 +10,8 @@ import { planLoader, readDocsConfig, readPlanConfig } from '../config.js';
 import { PLAN_ACTIONS, leadAnswerMessage, planCommitMessage } from '../plan-commit.js';
 import { articleRepoDir, articlesBrief, docSyncBrief, docSyncGaps, filesOf, gapMessage } from '../docsync.js';
 import { testGateMissing } from '../testgate.js';
+import { citesPriorWork, precheckNothingToFind } from './precheck.js';
+import { PROBE_FAILED, PROBE_RESERVE, probeStep, probeVars, scheduleProbe } from './probe.js';
 import { changedFiles, dirtyPaths, gitCommonDir, isAncestor, readCommits, resolveCommit, restoreWorktree, tryGit } from '../git.js';
 import { blockingLots, gitCommitsIn } from './table.js';
 import { citedRefs } from '../link.js';
@@ -25,7 +27,7 @@ import { journalTokens, peakContext, mcpServersFor, playwrightDir, runSession, t
 import { cleanPlaywrightOutput, pushed, remoteAdvances, snapshot } from './guard.js';
 import { sumTokens } from './result.js';
 import { cutReport, EXTENSION_MS, MAX_EXTENSIONS, workTimeoutMs } from './timeouts.js';
-import { ACCEPT_SCHEMA, checkShape, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, SPEC_SCHEMA, WORK_SCHEMA } from './schemas.js';
+import { ACCEPT_SCHEMA, agentOf, checkShape, PRECHECK_SCHEMA, REVIEW_SCHEMA, schemaFor, SPEC_SCHEMA, WORK_SCHEMA } from './schemas.js';
 import { acceptationFile, acceptCommands, isAcceptList, acceptText, checkAcceptation, findAcceptation, isAcceptationFile, lockViolations, lotStartHead, parseAcceptation, planAcceptRuns, redSha, resealedRouge, sealAcceptation, setVert } from './accept.js';
 import { lotIds, referenceIdsText } from '../ref/coverage.js';
 import { avalFicheText, ficheContracts, ficheRules, hasScreenPart } from './aval.js';
@@ -485,6 +487,8 @@ function avalOf(c, kind) {
     // la revue courte d'un petit lot visible est sa seule passe : elle porte aussi la conformité à la maquette
     return kind === 'review-small' && l.small && l.visible && screen ? `${text}\n${avalFicheText('ux', o)}` : text;
 }
+/** Les étapes dont le programme rejoue la porte après la session (L399) : elles reçoivent ses commandes exactes et la part de machine (L350). La sonde écrit des tests : sans la porte, elle joue le runner seul et commite un test que `tsc` ou la qualité mettent au rouge, d'où une passe de correction pour rien. */
+const writesCode = (kind) => kind === 'implement' || kind === 'fix' || kind === 'probe';
 /** Consigne de la part de machine de la session (L350) ; vide quand la vague n'en a pas calculé. */
 const workersText = (c) => (c.wave.testWorkers ? testWorkersText(c.wave.testWorkers) : '');
 function briefFor(c, kind, local = false) {
@@ -492,7 +496,7 @@ function briefFor(c, kind, local = false) {
     const l = c.lot;
     const lot = plan.lot(l.lot);
     const tmpDir = c.wave.store.tmpDir(l.project, l.lot);
-    const vars = { chemin: wd(c), lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', tmp: tmpText(tmpDir), workers: kind === 'implement' || kind === 'fix' ? workersText(c) : '', gate: kind === 'implement' || kind === 'fix' ? gateText(c.config) : '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []), integration: c.integration ? integrationText(c.integration.base) : '' };
+    const vars = { chemin: wd(c), lot: l.lot, titre: headline(lot, l.goal), objectif: objective(lot, l.goal), commits: '', reponse: '', constats: '', spec: '', ux: uxText(c), choix: choixText(c.lot.choix ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', docs: kind === 'review' || kind === 'review-small' ? docsText(c) : '', news: '', captures: '', tmp: tmpText(tmpDir), workers: writesCode(kind) ? workersText(c) : '', gate: writesCode(kind) ? gateText(c.config) : '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []), integration: c.integration ? integrationText(c.integration.base) : '' };
     if (l.visible) {
         const pwDir = playwrightDir(c.wave.store.lotDir(l.project, l.lot));
         vars.news = newsText(l.lot, pwDir);
@@ -504,6 +508,8 @@ function briefFor(c, kind, local = false) {
     // la vérification des ids d'un document de référence sur l'écran fini : la passe ux, ou la revue courte d'un petit lot visible qui n'a que celle-là (comme la conformité, avalOf)
     if (kind === 'ux' || (kind === 'review-small' && l.small && l.visible))
         vars.ux = [vars.ux, referenceIdsText('ux', lotIds({ ...lot, goal: l.goal ?? lot.goal }))].filter(Boolean).join('\n');
+    if (kind === 'probe')
+        Object.assign(vars, probeVars(ficheOf(c), lotCommitLines(c), startSha(c), l.lot));
     if (kind === 'implement' || kind === 'fix')
         vars.decisions = decisionsText(humanDecisions(lot, lot.parent ? plan.lots().find((x) => x.id === lot.parent) : undefined));
     if (kind === 'precheck' && local)
@@ -574,7 +580,7 @@ function briefFor(c, kind, local = false) {
     }
     const brief = renderBrief(briefName(l, kind, !!c.integration), vars, c.wave.templates);
     // Les dépôts tiers (L456) : la consigne s'ajoute à tout brief d'écriture, sans passer par un gabarit (un gabarit modifié change l'empreinte que d'autres tests gardent).
-    return kind === 'implement' || kind === 'fix' || kind === 'spec' || kind === 'accept' ? `${brief}\n${tiersText(l.project, l.lot)}\n` : brief;
+    return ['implement', 'fix', 'spec', 'accept', 'probe'].includes(kind) ? `${brief}\n${tiersText(l.project, l.lot)}\n` : brief;
 }
 /** 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);
@@ -625,8 +631,8 @@ export function budgetStep(l) {
     const step = named ?? l.next;
     return step && step !== 'integrate' && WRITE_STEPS.includes(step) ? step : null;
 }
-/** Le budget du lot paie-t-il la passe de correction et la revue courte qui la suit ? Sans budget de lot : toujours. La part de l'escalade (L349) n'est pas à dépenser, sauf pour décider l'escalade elle-même (`escalating`). */
-const fixAffordable = (l, escalating = false) => l.budget === undefined || lotSpent(l) + REVIEW_RESERVE < l.budget - (escalating ? 0 : heldForEscalation(l));
+/** Le budget du lot paie-t-il la passe de correction et la revue courte qui la suit ? Sans budget de lot : toujours. La part de l'escalade (L349) n'est pas à dépenser, sauf pour décider l'escalade elle-même (`escalating`). `extra` : le coût d'une étape de plus devant elles (la sonde, L497). */
+const fixAffordable = (l, escalating = false, extra = 0) => l.budget === undefined || lotSpent(l) + extra + REVIEW_RESERVE < l.budget - (escalating ? 0 : heldForEscalation(l));
 /** Cause d'une suspension demandée par `--stop-after-current` (L79). */
 export const STOP_REQUESTED = 'arrêt demandé (--stop-after-current)';
 /** Le lot a-t-il été écarté de la vague par `--drop` (L79) ? */
@@ -677,11 +683,11 @@ async function session(c, kind, local = false) {
     const halt = halted(w, l);
     if (halt)
         return suspend(c, halt);
-    const write = kind === 'implement' || kind === 'fix' || kind === 'spec' || kind === 'accept';
+    const write = kind === 'probe' || WRITE_STEPS.includes(kind); // la sonde écrit (ses tests) mais le budget ne la borne pas : il est vérifié avant de la décider
     // Le budget du lot borne l'écriture, jamais la revue (L145) : une revue est jouée dès que le code est à relire (sauf tests rouges après une écriture, cf. REVIEW_RESERVE), la passe fix réserve son coût.
-    if (write && (lotOver(l) || (kind === 'fix' && !fixAffordable(l))))
+    if (WRITE_STEPS.includes(kind) && (lotOver(l) || (kind === 'fix' && !fixAffordable(l))))
         return overBudget(c, kind === 'fix' && !lotOver(l));
-    const model = kind === 'spec' || kind === 'accept' || kind === 'fiche' ? 'sonnet' : write ? (kind === 'fix' && l.escalation?.stage === 'fix' ? l.escalation.model : l.model) : local ? 'local' : kind === 'precheck' ? 'sonnet' : reviewModel(c, kind); // le contrôle préalable ne fait que lire : pas d'Opus
+    const model = ['spec', 'accept', 'fiche', 'probe'].includes(kind) ? 'sonnet' : write ? (kind === 'fix' && l.escalation?.stage === 'fix' ? l.escalation.model : l.model) : local ? 'local' : kind === 'precheck' ? 'sonnet' : reviewModel(c, kind); // le contrôle préalable ne fait que lire : pas d'Opus
     const effort = c.config.effort[kind === 'review-small' ? 'review' : kind];
     const before = await snapshot(wd(c));
     const neighbours = l.repos ?? [];
@@ -691,7 +697,7 @@ async function session(c, kind, local = false) {
     const sessionId = randomUUID();
     const step = { n, kind, model, ...(effort !== 'default' ? { effort } : {}), 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', precheck: 'implementing', spec: 'implementing', accept: 'implementing', maquette: 'reviewing', fiche: 'reviewing' };
+    const label = { implement: 'implementing', fix: 'fixing', review: 'reviewing', ux: 'reviewing', 'review-small': 'reviewing', precheck: 'implementing', spec: 'implementing', accept: 'implementing', maquette: 'reviewing', fiche: 'reviewing', probe: 'implementing' };
     transition(c, label[kind]);
     w.log(`${lotKey(l.project, l.lot)} · session ${n} ${kind} (${model})`);
     let brief;
@@ -742,7 +748,7 @@ async function session(c, kind, local = false) {
         effort,
         local,
         schema: schemaFor(kind),
-        agent: kind === 'spec' ? 'spec-writer' : kind === 'accept' ? 'acceptance-writer' : kind === 'ux' || kind === 'maquette' ? 'ux-reviewer' : kind === 'precheck' ? 'precheck-reader' : kind === 'fix' && l.docsFix ? 'doc-keeper' : write ? undefined : 'code-reviewer',
+        agent: kind === 'fix' && l.docsFix ? 'doc-keeper' : agentOf(kind),
         cwd: wd(c),
         wave: w.id,
         lot: lotKey(l.project, l.lot),
@@ -882,6 +888,19 @@ async function session(c, kind, local = false) {
             return null;
         step.status = 'failed';
         step.cause = outcome.cause;
+        if (kind === 'probe') {
+            // R9 : une sonde en échec ou coupée ne rend pas le lot. Ce qu'elle a laissé non commité est remis (suivis restaurés, nouveaux fichiers retirés), un warning le nomme.
+            // Coupée entre `git add` et son commit, elle laisse aussi l'index : il est désindexé d'abord, `restoreWorktree` ne remet que l'arbre de travail (sinon « AD q.spec.ts » et le lot rendu pour arbre sale).
+            // Un fichier à la fois : un chemin inconnu de l'index (non indexé) fait refuser toute la commande, les autres resteraient indexés.
+            const left = dirtBetween(before, await snapshot(wd(c)));
+            if (left.length) {
+                for (const f of left)
+                    tryGit(wd(c), ['restore', '--staged', '--', f]);
+                restoreWorktree(wd(c), left);
+                l.warnings.push(`sonde de cas limites : fichiers non commités laissés par la session retirés (${left.join(', ')})`);
+            }
+            return PROBE_FAILED;
+        }
         if (write && outcome.cause === 'délai dépassé') {
             // L298 : le travail laissé par une étape d'écriture coupée au délai est signalé (commits, fichiers, tests), pas un « échec » sec ; L303 : dans les dépôts voisins aussi.
             const repos = [{ rel: '', path: wd(c), before }, ...neighbours.map((r, i) => ({ rel: r.rel, path: r.path, before: beforeOthers[i] }))];
@@ -1282,43 +1301,6 @@ function badReport(c, step, e) {
     step.cause = e.message;
     return stop(c, 'failed', `${step.kind} : ${e.message}`);
 }
-/**
- * Mots du titre ou du goal qui disent que le lot reprend un constat : le livrable peut déjà exister. Mots entiers (« review » ne
- * se lit pas dans `qa-reviewer` ni `review-small`), au pluriel ou accordés pour « constat ».
- */
-const CITES_FINDING = /(?<![\w-])(?:constat\w*|revues?|reviews?|audits?)(?![\w-])/i;
-/**
- * Le texte du lot (titre, goal, objectif donné) cite un constat, ou un autre lot dont le travail a pu être fait. Pour un lot
- * `L<n>`, « L12 » compte dans le texte de `L30` (aussi dans « L12-L15 », « L12-bis », « L12.3 ») et non celui de `L12` ni d'un lot postérieur ; tout identifiant du plan qui n'est
- * pas `L<n>` (`Q-CAN5`, `B28.1`, `Q4/qa-expectations`) compte cité en entier (`B28.1` n'est pas `B28.10`), pour un lot `L<n>`
- * comme pour un autre ; un lot d'un autre projet (`cadence:L68`) compte toujours.
- */
-function citesPriorWork(text, lot, ids) {
-    if (CITES_FINDING.test(text))
-        return true;
-    const { ids: cited, foreign } = citedLots(text, lot, ids);
-    return foreign || cited.length > 0;
-}
-/**
- * Les lots que le texte cite (même reconnaissance que `citesPriorWork`, L288/L292) : les identifiants du plan cités, et `foreign` quand il cite un lot d'un autre projet
- * (`cadence:L68`, dont on ne lit pas les commits ici).
- */
-function citedLots(text, lot, ids) {
-    const foreign = /(?<![\w-])[a-z][\w-]*:L\d+(?!\w)/i.test(text);
-    const own = /^L(\d+)$/.exec(lot);
-    const cited = (id) => new RegExp(`(?<![\\w.-])${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![\\w-]|\\.\\w)`).test(text);
-    return {
-        foreign,
-        ids: ids.filter((id) => {
-            if (id === lot)
-                return false;
-            const n = /^L(\d+)$/.exec(id);
-            if (own && n)
-                return Number(n[1]) < Number(own[1]) && new RegExp(`(?<![\\w-])${id}(?!\\w)`).test(text);
-            return cited(id);
-        }),
-    };
-}
 /**
  * Le contrôle préalable ne vaut que pour un lot sans commit (avec des commits, l'implémentation reprend légitimement) dont le
  * titre ou le goal (clé `goal:` du plan, ou `goal` donné au lancement) cite un constat ou un autre lot (L288, L292) : sans cela
@@ -1335,44 +1317,7 @@ export function needsPrecheck(config, plan, repo, lot, repos = [], goal) {
     const text = [l.title, l.goal, goal].filter(Boolean).join('\n');
     return citesPriorWork(text, lot, plan.lots().map((x) => x.id));
 }
-/**
- * Un lot créé après le dernier commit de code du dépôt n'a rien à retrouver (L322) : tout ce que le dépôt contient date d'avant le lot, donc aucun autre lot ne l'a livré.
- * Rend la raison à écrire au journal, ou null quand le contrôle garde un sens. Le lot est daté par le commit qui a ajouté son id au plan, borné par sa clé `created` (une
- * migration ou un déplacement du plan ne rajeunit pas un vieux lot) ; le dernier commit de code est le dernier qui ne touche pas que le plan (`isPlanOnly`). Prudent : lot
- * qui travaille dans des dépôts voisins, id introuvable dans l'historique du plan, dépôt sans commit de code ou instants égaux → le contrôle reste.
- * Le contrôle reste aussi quand le titre ou le goal (ou le goal donné au lancement) cite un lot qui a déjà ses propres commits, ou un lot d'un autre projet : une « suite de revue L<n> » écrite
- * juste après le dernier correctif de L<n> liste des constats que les passes de correction de L<n> ont pu régler avant la création du lot (rejoué depuis le 24-10 : 5 lots sautés à tort,
- * dont 2 avec un vrai « partiel »).
- */
-export function precheckNothingToFind(plan, root, lot, repos = [], goal) {
-    if (repos.length)
-        return null;
-    try {
-        const rel = relative(root, plan.path);
-        const idLine = `^\\s*- id: ["']?${lot.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&')}["']?\\s*$`;
-        // Pas de `--reverse` : avec `--follow`, git 2.43 ne rend rien sur un fichier renommé (`raf migrate`) ; le plus ancien est la dernière ligne.
-        const added = git(root, '-c', 'core.quotepath=off', 'log', '--follow', '--format=%ct', '-G', idLine, '--', rel).split('\n').filter(Boolean).pop();
-        if (!added)
-            return null;
-        const created = plan.lot(lot).created;
-        const endOfCreated = created ? Date.parse(`${created}T23:59:59`) / 1000 : Infinity;
-        const createdAt = Math.min(Number(added), Number.isNaN(endOfCreated) ? Infinity : endOfCreated);
-        const log = git(root, 'log', '--format=%H %ct').split('\n').filter(Boolean);
-        const code = log.map((x) => x.split(' ')).find(([sha]) => !isPlanOnly(sha, plan, root));
-        if (!code)
-            return null;
-        if (createdAt <= Number(code[1]))
-            return null;
-        const l = plan.lot(lot);
-        const { ids, foreign } = citedLots([l.title, l.goal, goal].filter(Boolean).join('\n'), lot, plan.lots().map((x) => x.id));
-        if (foreign || ids.some((id) => lotWork(plan, root, id).length > 0))
-            return null;
-        return `lot créé après le dernier commit de code du dépôt (${code[0].slice(0, 7)}) : rien à retrouver`;
-    }
-    catch {
-        return null;
-    }
-}
+export { precheckNothingToFind };
 /**
  * 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.
@@ -2144,6 +2089,8 @@ export function redExcerpt(k) {
     const more = named.length > EXCERPT_LINES ? [`… (+${named.length - EXCERPT_LINES})`] : [];
     return [head.replace(/\s*:$/, ''), ...shown, ...more].join(' ; ');
 }
+/** Violations du verrou des tests d'acceptation (L173) par les commits faits depuis `head` ; aucune sans HEAD de départ. */
+const sealedViolations = (c, head) => (head ? lockViolations(wd(c), c.config.spec.dir, head, { rouge: c.lot.accept?.rouge ? { [c.lot.accept.acceptation]: c.lot.accept.rouge } : {}, lot: c.lot.lot, lotBase: c.lot.steps.find((s) => s.headBefore)?.headBefore, lotStart: lotStartHead(wd(c), lotWork(histPlan(c), wd(c), c.lot.lot).map((k) => k.sha)), lotCommits: lotCommits(histPlan(c), wd(c), c.lot.lot).map((k) => k.sha) }) : []);
 /** Étape d'écriture (implémentation, correction) : contrôles, puis étape suivante décidée. */
 async function work(c, kind) {
     const l = c.lot;
@@ -2206,7 +2153,7 @@ async function work(c, kind) {
     save(c);
     // Verrou des tests d'acceptation (L173) : ceux de TOUS les lots du dépôt, pas seulement du lot courant ; une modification est une question au lead. Contrôlé à CHAQUE fin de session, une question comprise (L200) :
     // une session qui remplace un test scellé puis pose une question ne passe pas par la reprise du lead pour se faire adopter.
-    const locked = done.step.headBefore ? lockViolations(wd(c), c.config.spec.dir, done.step.headBefore, { rouge: l.accept?.rouge ? { [l.accept.acceptation]: l.accept.rouge } : {}, lot: l.lot, lotBase: l.steps.find((s) => s.headBefore)?.headBefore, lotStart: lotStartHead(wd(c), lotWork(histPlan(c), wd(c), l.lot).map((k) => k.sha)), lotCommits: lotCommits(histPlan(c), wd(c), l.lot).map((k) => k.sha) }) : [];
+    const locked = sealedViolations(c, done.step.headBefore);
     if (locked.length) {
         stop(c, 'handed-back', `verrou des tests d'acceptation : ${locked.join(' ; ')}`);
         return;
@@ -2350,7 +2297,18 @@ async function work(c, kind) {
             }
         }
     }
-    // Bibliothécaire (L306) : docs.sync signale un document en retard sur les commits du lot → une passe doc-keeper avant la revue, une seule fois par lot, aux mêmes conditions de passe et de budget que la porte ci-dessus. Si elle ne touche pas le document, la revue part et porte l'écart (brief docs.sync, constat majeur).
+    // Sonde de cas limites (L497) : une fois par lot, après la porte « code sans test », avant le bibliothécaire et la revue.
+    if (scheduleProbe(c.config, l, { skip: minorsPass || !alreadyDone, late: l.pass >= MAX_PASSES - 1, pays: fixAffordable(l, false, PROBE_RESERVE), count: budgetCount(l) })) {
+        // Les contrôles de la porte restent au lot pendant la sonde : sans nouveau commit de sa part, la revue les reprend pour ce HEAD.
+        l.checks = runs.length ? { head: git(wd(c), 'rev-parse', 'HEAD'), tree: git(wd(c), 'rev-parse', 'HEAD^{tree}'), runs } : undefined;
+        return save(c);
+    }
+    await toReview(c, runs, minorsPass);
+}
+/** Fin d'une écriture dont les portes sont passées : le bibliothécaire (L306), puis la première revue. Aussi la suite d'une sonde (L497) qui n'a rien à corriger. */
+async function toReview(c, runs, minorsPass) {
+    const l = c.lot;
+    // Bibliothécaire (L306) : docs.sync signale un document en retard sur les commits du lot → une passe doc-keeper avant la revue, une seule fois par lot, aux mêmes conditions de passe et de budget que la porte « code sans test ». Si elle ne touche pas le document, la revue part et porte l'écart (brief docs.sync, constat majeur).
     if (!l.docsGate && !minorsPass) {
         const { gaps } = docGaps(c);
         if (gaps.length) {
@@ -2372,6 +2330,11 @@ async function work(c, kind) {
     l.next = firstReview(c);
     save(c);
 }
+/** Ce que la sonde (probe.ts) emprunte au cycle. */
+const probeIo = (c) => ({
+    lot: c.lot, config: c.config, cwd: wd(c), play: () => session(c, 'probe'), take: (step, rep) => takeReport(c, { step }, rep), sealed: (head) => sealedViolations(c, head), dirt: dirtAfter, gate: (red, runs) => programChecks(c, red, runs),
+    fix: (constats) => toFix(c, constats, 'sonde de cas limites'), review: (runs) => toReview(c, runs, false), handBack: (why) => void stop(c, 'handed-back', why), pays: () => fixAffordable(c.lot), head: () => git(wd(c), 'rev-parse', 'HEAD').trim(),
+});
 /** Mention « sans commit » du verdict quand la passe des mineurs n'a rien commité (l'UX finale conclut alors à la place de la passe). */
 const noCommitNote = (l) => (l.warnings.some((w) => w.startsWith('passe des mineurs sans commit')) ? ' sans commit' : '');
 /** Revue de code qui clôt le cycle : complète, ou courte une fois la passe des mineurs jouée. */
@@ -3104,6 +3067,8 @@ export async function runLot(c) {
                 await acceptStep(c);
             else if (kind === 'implement' || kind === 'fix')
                 await work(c, kind);
+            else if (kind === 'probe')
+                await probeStep(probeIo(c));
             else if (kind === 'integrate')
                 await integrateLot(c);
             else

package/dist/orchestrate/precheck.js

@@ -0,0 +1,79 @@
+// Les critères du contrôle préalable (L77, L288, L292, L322) : un lot qui cite un constat ou un autre lot, et un lot créé après le dernier commit de code, qui n'a rien à retrouver.
+import { relative } from 'node:path';
+import { isPlanOnly, lotWork } from '../audit.js';
+import { git } from './worktree.js';
+/**
+ * Mots du titre ou du goal qui disent que le lot reprend un constat : le livrable peut déjà exister. Mots entiers (« review » ne
+ * se lit pas dans `qa-reviewer` ni `review-small`), au pluriel ou accordés pour « constat ».
+ */
+const CITES_FINDING = /(?<![\w-])(?:constat\w*|revues?|reviews?|audits?)(?![\w-])/i;
+/**
+ * Le texte du lot (titre, goal, objectif donné) cite un constat, ou un autre lot dont le travail a pu être fait. Pour un lot
+ * `L<n>`, « L12 » compte dans le texte de `L30` (aussi dans « L12-L15 », « L12-bis », « L12.3 ») et non celui de `L12` ni d'un lot postérieur ; tout identifiant du plan qui n'est
+ * pas `L<n>` (`Q-CAN5`, `B28.1`, `Q4/qa-expectations`) compte cité en entier (`B28.1` n'est pas `B28.10`), pour un lot `L<n>`
+ * comme pour un autre ; un lot d'un autre projet (`cadence:L68`) compte toujours.
+ */
+export function citesPriorWork(text, lot, ids) {
+    if (CITES_FINDING.test(text))
+        return true;
+    const { ids: cited, foreign } = citedLots(text, lot, ids);
+    return foreign || cited.length > 0;
+}
+/**
+ * Les lots que le texte cite (même reconnaissance que `citesPriorWork`, L288/L292) : les identifiants du plan cités, et `foreign` quand il cite un lot d'un autre projet
+ * (`cadence:L68`, dont on ne lit pas les commits ici).
+ */
+function citedLots(text, lot, ids) {
+    const foreign = /(?<![\w-])[a-z][\w-]*:L\d+(?!\w)/i.test(text);
+    const own = /^L(\d+)$/.exec(lot);
+    const cited = (id) => new RegExp(`(?<![\\w.-])${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![\\w-]|\\.\\w)`).test(text);
+    return {
+        foreign,
+        ids: ids.filter((id) => {
+            if (id === lot)
+                return false;
+            const n = /^L(\d+)$/.exec(id);
+            if (own && n)
+                return Number(n[1]) < Number(own[1]) && new RegExp(`(?<![\\w-])${id}(?!\\w)`).test(text);
+            return cited(id);
+        }),
+    };
+}
+/**
+ * Un lot créé après le dernier commit de code du dépôt n'a rien à retrouver (L322) : tout ce que le dépôt contient date d'avant le lot, donc aucun autre lot ne l'a livré.
+ * Rend la raison à écrire au journal, ou null quand le contrôle garde un sens. Le lot est daté par le commit qui a ajouté son id au plan, borné par sa clé `created` (une
+ * migration ou un déplacement du plan ne rajeunit pas un vieux lot) ; le dernier commit de code est le dernier qui ne touche pas que le plan (`isPlanOnly`). Prudent : lot
+ * qui travaille dans des dépôts voisins, id introuvable dans l'historique du plan, dépôt sans commit de code ou instants égaux → le contrôle reste.
+ * Le contrôle reste aussi quand le titre ou le goal (ou le goal donné au lancement) cite un lot qui a déjà ses propres commits, ou un lot d'un autre projet : une « suite de revue L<n> » écrite
+ * juste après le dernier correctif de L<n> liste des constats que les passes de correction de L<n> ont pu régler avant la création du lot (rejoué depuis le 24-10 : 5 lots sautés à tort,
+ * dont 2 avec un vrai « partiel »).
+ */
+export function precheckNothingToFind(plan, root, lot, repos = [], goal) {
+    if (repos.length)
+        return null;
+    try {
+        const rel = relative(root, plan.path);
+        const idLine = `^\\s*- id: ["']?${lot.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&')}["']?\\s*$`;
+        // Pas de `--reverse` : avec `--follow`, git 2.43 ne rend rien sur un fichier renommé (`raf migrate`) ; le plus ancien est la dernière ligne.
+        const added = git(root, '-c', 'core.quotepath=off', 'log', '--follow', '--format=%ct', '-G', idLine, '--', rel).split('\n').filter(Boolean).pop();
+        if (!added)
+            return null;
+        const created = plan.lot(lot).created;
+        const endOfCreated = created ? Date.parse(`${created}T23:59:59`) / 1000 : Infinity;
+        const createdAt = Math.min(Number(added), Number.isNaN(endOfCreated) ? Infinity : endOfCreated);
+        const log = git(root, 'log', '--format=%H %ct').split('\n').filter(Boolean);
+        const code = log.map((x) => x.split(' ')).find(([sha]) => !isPlanOnly(sha, plan, root));
+        if (!code)
+            return null;
+        if (createdAt <= Number(code[1]))
+            return null;
+        const l = plan.lot(lot);
+        const { ids, foreign } = citedLots([l.title, l.goal, goal].filter(Boolean).join('\n'), lot, plan.lots().map((x) => x.id));
+        if (foreign || ids.some((id) => lotWork(plan, root, id).length > 0))
+            return null;
+        return `lot créé après le dernier commit de code du dépôt (${code[0].slice(0, 7)}) : rien à retrouver`;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/orchestrate/probe.js

@@ -0,0 +1,124 @@
+import { docSyncSet, filesOf } from '../docsync.js';
+import { readCommits } from '../git.js';
+import { checkShape, PROBE_SCHEMA } from './schemas.js';
+/** Rendu par la session de la sonde quand elle n'a rien donné (échec, coupure, délai) : la sonde ne bloque jamais le lot, un warning et la revue part. */
+export const PROBE_FAILED = Symbol('probe-failed');
+/**
+ * Coût réservé à la sonde en plus de la correction et de la revue qui la suit : une session Sonnet d'écriture. ESTIMATION, aucune mesure (la sonde n'a pas encore joué) :
+ * le p90 d'une passe fix Sonnet, 65 k tokens comptés (mesure du 2026-10-15, voir REVIEW_RESERVE). À remesurer sur les premières sondes (`cadence perf`, étape probe).
+ */
+export const PROBE_RESERVE = 65_000;
+/** Préfixe du texte d'un constat de la sonde : il distingue, dans le journal, la passe de correction qu'elle déclenche. */
+const PROBE_FINDING = 'sonde de cas limites : ';
+/**
+ * Décide la sonde d'un lot (R3, R6) : vrai quand elle est la prochaine étape. Décidée une seule fois par lot (`l.probe`), jouée ou écartée avec un warning qui dit pourquoi.
+ * Sans la clé `orchestrate.probe`, rien : ni champ ni warning.
+ */
+export function scheduleProbe(config, l, o) {
+    if (!config.probe || l.probe || o.skip)
+        return false;
+    l.probe = true;
+    if (!o.late && o.pays) {
+        l.next = 'probe';
+        return true;
+    }
+    l.warnings.push(`sonde de cas limites non jouée : ${l.pass} passe(s) de correction déjà faite(s) ou budget du lot (${o.count}) insuffisant`);
+    return false;
+}
+/** Les variables du brief de la sonde : la fiche du lot quand il en a une, ses commits, et la commande du diff (jamais le diff collé). */
+export function probeVars(fiche, commits, from, lot) {
+    return {
+        fiche: fiche ? `The lot has a spec sheet: \`${fiche}\`. Read it first: each of its rules (Rn) states a behaviour to attack, and its contracts give the exact errors the code must raise.` : '',
+        commits,
+        diff: from ? `git diff ${from}..HEAD` : `git log -p --reverse --grep=${lot}`,
+    };
+}
+const unplayed = (l, why) => l.warnings.push(`sonde de cas limites non jouée : ${why}`);
+/** Le rapport de la session, ou un warning « non jouée » quand il est illisible (la revue part quand même). */
+function readReport(l, report) {
+    try {
+        return checkShape(report, PROBE_SCHEMA);
+    }
+    catch (e) {
+        unplayed(l, e.message);
+        return undefined;
+    }
+}
+/** Les fichiers commités par la sonde qui ne sont pas des tests (R8) : un warning les nomme, rien n'est retiré. Sans `testGate.tests` déclaré, rien ne distingue un test d'un autre. */
+function warnOutsideTests(io, headBefore) {
+    const tests = io.config.testGate?.tests;
+    if (!tests)
+        return;
+    const isTest = docSyncSet(tests);
+    const outside = [...filesOf(io.cwd, readCommits(io.cwd, { range: headBefore ? `${headBefore}..HEAD` : undefined }))].filter((f) => !isTest(f)).sort();
+    if (outside.length)
+        io.lot.warnings.push(`sonde de cas limites : la session a modifié du code hors tests (${outside.join(', ')})`);
+}
+/** Les contrôles faits après une session qui a commité, avec ou sans rapport : verrou, dépôt propre (`dirt`), fichiers hors tests. Vrai quand le lot est rendu. */
+function handedBack(io, dirt, headBefore) {
+    const locked = io.sealed(headBefore);
+    const why = locked.length ? `verrou des tests d'acceptation : ${locked.join(' ; ')}` : dirt.length ? `dépôt sale après probe : ${dirt.join(', ')}` : '';
+    if (why)
+        io.handBack(why);
+    else
+        warnOutsideTests(io, headBefore);
+    return !!why;
+}
+/**
+ * Les constats de la sonde (R4, R5) : les rouges NOUVEAUX de la porte du programme (jamais un échec déjà rouge au départ), en gravité majeure, avec ce que la session annonce
+ * (« test — borne — attendu ») pour que la correction voie la borne. Sans `orchestrate.test`, les échecs annoncés tels quels, dits non vérifiés par le programme.
+ */
+function findings(l, red, claimed, gated) {
+    const said = claimed.length ? `\nLa sonde annonce : ${claimed.join(' ; ')}` : '';
+    const out = red.map((k) => ({ ...k, gravite: 'majeur', texte: `${PROBE_FINDING}${k.texte}${said}` }));
+    if (gated || !claimed.length)
+        return out;
+    l.warnings.push('sonde de cas limites : échecs annoncés par la session, non vérifié par le programme (orchestrate.test absent)');
+    return [...out, ...claimed.map((e) => ({ source: 'tests', gravite: 'majeur', texte: `${PROBE_FINDING}${e}` }))];
+}
+/**
+ * Joue la sonde (R3 à R9). Elle ne bloque jamais le lot : échec, coupure, délai ou rapport illisible sont un warning et la revue part. Seuls un quota (suspension : la reprise rejoue la sonde),
+ * un verrou d'acceptation violé ou un dépôt sale le rendent, comme après toute session d'écriture. Un test rouge nouveau repart en correction ; sinon le cycle reprend (bibliothécaire, revue).
+ */
+export async function probeStep(io) {
+    const l = io.lot;
+    const done = await io.play();
+    if (!done)
+        return;
+    const step = l.steps[l.steps.length - 1];
+    const rep = done === PROBE_FAILED ? cutSession(io, step) : readSession(io, done, step);
+    if (rep === 'rendu')
+        return;
+    // La porte du programme après la sonde comme après toute écriture, mais seulement si elle a commité : sans nouveau commit il n'y a rien de neuf à rejouer.
+    const red = [];
+    const runs = [];
+    const moved = !!step.headBefore && io.head() !== step.headBefore;
+    if (moved)
+        await io.gate(red, runs);
+    const found = moved ? findings(l, red, (rep?.echecs ?? []).map((e) => e.trim()).filter(Boolean), !!io.config.test) : [];
+    if (found.length) {
+        // Une correction que le budget ne paie plus n'est pas sautée : l'étape fix refuse et le lot revient au lead sans revue, tests rouges (L145, cycle.ts overBudget).
+        if (io.pays())
+            l.warnings.push(`${PROBE_FINDING}${found.length} constat(s), passe de correction avant la revue`);
+        step.constats = found.map((k) => k.texte);
+        io.fix(found);
+        return;
+    }
+    // Sans nouveau commit, les contrôles de la porte jouée après l'écriture valent toujours pour ce HEAD : la revue les garde (sinon elle relance la suite et le build).
+    await io.review(moved ? runs : [...(l.checks?.runs ?? [])]);
+}
+/** La session n'a rien donné (échec, coupure, délai) : un warning, pas de rapport. Ce qu'elle a commité avant d'être coupée passe les mêmes contrôles qu'après un rapport (commits au journal, verrou, fichiers hors tests) ; le dépôt a déjà été remis propre. */
+function cutSession(io, step) {
+    unplayed(io.lot, step.cause ?? 'échec');
+    if (!step.headBefore || io.head() === step.headBefore)
+        return undefined;
+    io.take(step, { questions: [] });
+    return handedBack(io, [], step.headBefore) ? 'rendu' : undefined;
+}
+/** Le rapport d'une session qui a répondu : questions notées, verrou et dépôt contrôlés. `'rendu'` quand le lot est rendu. */
+function readSession(io, done, step) {
+    const rep = readReport(io.lot, done.report);
+    for (const q of io.take(step, rep ?? { questions: [] }))
+        io.lot.warnings.push(`sonde de cas limites : question sans réponse (la sonde ne bloque pas le lot) : « ${q.trim()} »`);
+    return handedBack(io, io.dirt(done), step.headBefore) ? 'rendu' : rep;
+}

package/dist/orchestrate/schemas.js

@@ -53,8 +53,17 @@ export const PRECHECK_SCHEMA = {
     properties: { dejaPresent: { type: 'string', enum: ['oui', 'partiel', 'non'] }, preuves: strings, resume: str },
     required: ['dejaPresent', 'preuves', 'resume'],
 };
+/** Sortie de la sonde de cas limites (L497) : les tests commités, et `echecs` les tests qu'elle annonce rouges (« test — borne — attendu », un par entrée). */
+export const PROBE_SCHEMA = {
+    type: 'object',
+    properties: { commits: WORK_SCHEMA.properties.commits, echecs: strings, nonVerifie: strings, questions: strings, choix: strings, resume: str },
+    required: ['commits', 'echecs', 'nonVerifie', 'questions', 'resume'],
+};
 /** Une revue de maquette rend le même rapport qu'une revue d'ergonomie (REVIEW_SCHEMA). */
-export const schemaFor = (kind) => (kind === 'precheck' ? PRECHECK_SCHEMA : kind === 'spec' ? SPEC_SCHEMA : kind === 'accept' ? ACCEPT_SCHEMA : kind === 'implement' || kind === 'fix' ? WORK_SCHEMA : REVIEW_SCHEMA);
+export const schemaFor = (kind) => (kind === 'precheck' ? PRECHECK_SCHEMA : kind === 'spec' ? SPEC_SCHEMA : kind === 'accept' ? ACCEPT_SCHEMA : kind === 'probe' ? PROBE_SCHEMA : kind === 'implement' || kind === 'fix' ? WORK_SCHEMA : REVIEW_SCHEMA);
+/** L'agent du paquet de chaque étape qui en a un, ou `undefined` pour une écriture sans agent ; les revues et la fiche n'y sont pas : `code-reviewer`. */
+const STEP_AGENT = { implement: undefined, fix: undefined, probe: undefined, spec: 'spec-writer', accept: 'acceptance-writer', ux: 'ux-reviewer', maquette: 'ux-reviewer', precheck: 'precheck-reader' };
+export const agentOf = (kind) => (kind in STEP_AGENT ? STEP_AGENT[kind] : 'code-reviewer');
 /** Contrôle la forme d'une sortie structurée : un champ absent ou mal typé est une erreur nommée. */
 export function checkShape(value, schema) {
     if (!value || typeof value !== 'object' || Array.isArray(value))

package/dist/perf.js

@@ -48,7 +48,7 @@ function planLot(plans, project, lot) {
     return lots.find((l) => l.id === lot) ?? (lot.includes('/') ? lots.find((l) => l.id === lot.slice(0, lot.indexOf('/'))) : undefined);
 }
 /** Rang d'affichage d'une sorte d'étape : l'ordre du cycle, les sortes inconnues après. */
-const KIND_ORDER = ['spec', 'maquette', 'fiche', 'precheck', 'implement', 'review', 'review-small', 'ux', 'fix', 'accept'];
+const KIND_ORDER = ['spec', 'maquette', 'fiche', 'precheck', 'implement', 'probe', 'review', 'review-small', 'ux', 'fix', 'accept'];
 const kindRank = (kind) => (KIND_ORDER.includes(kind) ? KIND_ORDER.indexOf(kind) : KIND_ORDER.length);
 /** Part de `counted` rangée en entrée quand une étape ne porte que ce compteur (journal ancien) : le reste est en sortie (R8 b). */
 const COUNTED_INPUT_SHARE = 0.9;

package/dist/plan-commit.js

@@ -4,13 +4,13 @@ import { tmpdir } from 'node:os';
 import { isAbsolute, join, resolve } from 'node:path';
 import { tryGit } from './git.js';
 /** Gabarit par défaut du message d'un commit de plan écrit dans une vague (L343 : inchangé depuis toujours). */
-export const PLAN_COMMIT_WAVE = 'plan: {lot} {action} (orchestrate {vague})';
+const PLAN_COMMIT_WAVE = 'plan: {lot} {action} (orchestrate {vague})';
 /** Gabarit par défaut hors vague (`spec reseal`) : pas de vague à citer. */
-export const PLAN_COMMIT_PLAIN = 'plan: {lot} {action}';
+const PLAN_COMMIT_PLAIN = 'plan: {lot} {action}';
 /** Gabarit par défaut du commit de la fiche sourcée par la réponse du lead : type `docs`, déjà conventionnel (L343). */
-export const LEAD_ANSWER_COMMIT = 'docs({lot}): {action} (orchestrate {vague})';
+const LEAD_ANSWER_COMMIT = 'docs({lot}): {action} (orchestrate {vague})';
 /** Les mots que le gabarit `plan.commit` de cadence.yaml peut employer. */
-export const PLAN_COMMIT_FIELDS = ['lot', 'action', 'vague'];
+const PLAN_COMMIT_FIELDS = ['lot', 'action', 'vague'];
 /** Ce que cadence écrit dans un commit de plan, par action : une seule source pour la vague et pour le dry-run. */
 export const PLAN_ACTIONS = {
     started: 'démarré',

package/dist/plan.js

@@ -24,7 +24,7 @@ export function setPlanNotice(fn) {
     notice = fn;
 }
 export const STATUSES = ['todo', 'doing', 'done', 'dropped'];
-export const GATE_INVALID = 'gate invalide : count: entier ≥ 1 et un critère spec: true ou screen: page attendus';
+const GATE_INVALID = 'gate invalide : count: entier ≥ 1 et un critère spec: true ou screen: page attendus';
 export class RafError extends Error {
 }
 /** Un nom de ressource partagée (L251) : un mot de lettres minuscules, chiffres, « - » et « _ ». */
@@ -32,7 +32,7 @@ export const RESOURCE_NAME = /^[a-z0-9_-]+$/;
 export const RESOURCES_BAD_LIST = 'doit être une liste de noms de ressources';
 export const invalidResource = (name) => `ressource invalide : ${name === '' ? '(vide)' : name} (lettres minuscules, chiffres, - et _)`;
 /** Les noms de ressources de `--uses` ou de `raf uses` : chacun valide (`RafError` sinon), sans doublon, dans l'ordre donné. */
-export function cleanUses(names) {
+function cleanUses(names) {
     for (const n of names)
         if (!RESOURCE_NAME.test(n))
             throw new RafError(invalidResource(n));
@@ -54,7 +54,7 @@ export function escapeRe(s) {
  */
 const DOTTED = '\\.\\w';
 /** Matches `L3` or `L3/t1` as whole words. Group 1 = lot id, group 2 = task id. */
-export function refPattern(prefix) {
+function refPattern(prefix) {
     return new RegExp(`(?<![\\w/])(${escapeRe(prefix)}\\d+)(?:/(t\\d+))?(?!\\w|${DOTTED})`, 'g');
 }
 export function extractRefs(text, prefix) {

package/dist/proc.js

@@ -124,7 +124,7 @@ export function processStart(pid) {
 /** Âge au-delà duquel un relevé de secours (le relevé suivant a échoué) n'est plus cru : un pid y a pu être repris. */
 export const MAX_SNAPSHOT_AGE_MS = 1_000;
 /** Intervalle du relevé des descendants d'une commande de deliver pendant qu'elle tourne. */
-export const TRACK_INTERVAL_MS = 200;
+const TRACK_INTERVAL_MS = 200;
 /**
  * Suivi continu de l'arbre d'une commande : toutes les TRACK_INTERVAL_MS, ses descendants sont relevés et
  * chacun est retenu avec son heure de démarrage. Un processus vu une fois reste suivi même si son parent

package/dist/ref/add.js

@@ -7,7 +7,7 @@ import { DPI, extractImages, imageFile, imageRegions, listImages, pageCount, ren
 import { readDocument, writeDocument } from './store.js';
 import { requireTools } from './tools.js';
 /** Sans `--sections`, un document de cette taille ou plus petit est rendu en entier ; au-delà, seul l'index est construit. */
-export const WHOLE_DOCUMENT_MAX = 30;
+const WHOLE_DOCUMENT_MAX = 30;
 /** Une page de moins de 20 caractères de texte est tenue pour scannée (recette du skill norme-etude). */
 const SCANNED_MAX_CHARS = 20;
 /** [1, 2, 3, 6] → « 1-3, 6 ». */
@@ -23,7 +23,7 @@ function ranges(pages) {
     return out.join(', ');
 }
 /** `3-5,9` → [3, 4, 5, 9] (pages du PDF, 1 = première), sans doublon, dans l'ordre. */
-export function parseSections(text, pages) {
+function parseSections(text, pages) {
     const out = new Set();
     for (const part of text.split(',')) {
         const m = /^\s*(\d+)(?:\s*-\s*(\d+))?\s*$/.exec(part);

package/dist/ref/analyse.js

@@ -9,9 +9,9 @@ import { troisiemeRegard } from './regard.js';
 import { sessionDeRef } from './session.js';
 /** Plafond déclaré d'une lecture : au plus 20 pages rendues lues d'un coup (design §5, « Taille »). Au-delà, `--sections` en choisit moins. */
 export const LECTURE_PAGES_MAX = 20;
-export const ANALYSE_MODELS = ['sonnet', 'opus', 'haiku'];
+const ANALYSE_MODELS = ['sonnet', 'opus', 'haiku'];
 /** Sortie structurée de la session : ce que l'agent dit de sa lecture ; le programme ne s'y fie pas, il relit le fichier. */
-export const ANALYSE_SCHEMA = {
+const ANALYSE_SCHEMA = {
     type: 'object',
     properties: {
         resume: { type: 'string', description: 'Two sentences: what the document is and what the reading holds.' },

package/dist/ref/coverage.js

@@ -20,7 +20,7 @@ export function lotIds(lot) {
     return idsInText([lot.title, lot.goal ?? '', ...lot.notes.map((n) => n.text).filter((t) => !isProgramNote(t))].join('\n'));
 }
 /** Les éléments que la fiche d'un lot justifie comme non pris (`<id> : <raison>` dans `sujet.perimetre.hors_perimetre`), par id. */
-export function nonPris(repo, specDir, lotId) {
+function nonPris(repo, specDir, lotId) {
     const out = new Map();
     const doc = fichesDuDossier(repo, specDir).find(({ doc }) => doc.sujet?.lot === lotId)?.doc;
     const sujet = doc?.sujet;
@@ -64,7 +64,7 @@ function where(e) {
  * Calcule la couverture d'un inventaire valide par les lots du plan (fait, abandonné compté pour rien) et par ses exclusions écrites. Un lot fait dont la fiche
  * justifie un élément comme non pris (`justifies`) ne le couvre pas : l'élément reste un écart tant que le lead ne l'a pas exclu par écrit ou fait par un autre lot.
  */
-export function computeCoverage(inventaire, lots, justifies = () => new Map()) {
+function computeCoverage(inventaire, lots, justifies = () => new Map()) {
     const elements = inventaire.elements;
     const known = new Set(elements.map((e) => e.id));
     const byId = new Map();

package/dist/ref/diff.js

@@ -305,7 +305,7 @@ export function reprendreIds(lecture, precedent) {
         lecture.exclusions = precedent.exclusions;
 }
 /** L'inventaire que `--out` va remplacer, s'il en est un de valide ; sinon rien (un fichier illisible ou d'une autre forme n'est pas un inventaire précédent). */
-export function inventairePrecedent(path) {
+function inventairePrecedent(path) {
     if (!existsSync(path))
         return undefined;
     try {