@sylad/cadence 0.14.0 → 0.16.0

package/dist/lead.js

@@ -16,27 +16,42 @@ const empty = (project) => ({ project, doing: [], drift: [], notes: [], next: nu
 export function truncate(text, max) {
     return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
-/** Sous-dossiers directs qui portent un plan : docs/plan/raf.yaml, ou un cadence.yaml avec `plan:`. */
-export function findProjects(parent) {
-    return readdirSync(parent, { withFileTypes: true })
-        .filter((e) => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules')
-        .map((e) => join(parent, e.name))
-        .filter((dir) => {
-        if (existsSync(join(dir, 'docs/plan/raf.yaml')))
-            return true;
-        const conf = join(dir, 'cadence.yaml');
-        if (!existsSync(conf) || !statSync(conf).isFile())
-            return false;
-        try {
-            const c = readPlanConfig(conf);
-            // Une clé qa: seule ne désigne aucun plan.
-            return !!c && (!!c.path || Object.keys(c.settings).some((k) => k !== 'qaExpectations'));
-        }
-        catch {
-            return true; // un cadence.yaml illisible reste un projet : sa ligne dit l'erreur
-        }
-    })
-        .sort();
+/** Un dossier est un projet s'il porte docs/plan/raf.yaml, ou un cadence.yaml avec `plan:`. */
+function isProject(dir) {
+    if (existsSync(join(dir, 'docs/plan/raf.yaml')))
+        return true;
+    const conf = join(dir, 'cadence.yaml');
+    if (!existsSync(conf) || !statSync(conf).isFile())
+        return false;
+    try {
+        const c = readPlanConfig(conf);
+        // Une clé qa: seule ne désigne aucun plan.
+        return !!c && (!!c.path || Object.keys(c.settings).some((k) => k !== 'qaExpectations'));
+    }
+    catch {
+        return true; // un cadence.yaml illisible reste un projet : sa ligne dit l'erreur
+    }
+}
+/** Les projets sous `parent`, jusqu'à `depth` niveaux (1 : sous-dossiers directs) ; on ne descend pas dans un projet. */
+export function findProjects(parent, depth = 1) {
+    const found = [];
+    let entries;
+    try {
+        entries = readdirSync(parent, { withFileTypes: true });
+    }
+    catch {
+        return found; // dossier illisible : on le saute, les autres projets tournent
+    }
+    for (const e of entries) {
+        if (!e.isDirectory() || e.name.startsWith('.') || e.name === 'node_modules')
+            continue;
+        const dir = join(parent, e.name);
+        if (isProject(dir))
+            found.push(dir);
+        else if (depth > 1)
+            found.push(...findProjects(dir, depth - 1));
+    }
+    return found.sort();
 }
 /** Les faits de `cadence session start` pour un projet, sous forme de données ; lecture seule. */
 export function tourRow(dir, today, idle = TOUR_IDLE) {

package/dist/orchestrate/briefs.js

@@ -4,6 +4,26 @@ import { fileURLToPath } from 'node:url';
 import { RafError } from '../plan.js';
 /** Gabarits livrés avec le paquet (à la racine, à côté de dist/ et src/). */
 export const TEMPLATES_DIR = fileURLToPath(new URL('../../templates/orchestrate', import.meta.url));
+/** Consigne sur les dépôts voisins d'un lot (L62) : les sessions d'écriture y travaillent, les relectures y lisent les commits qui citent le lot. */
+export function reposText(role, lot, repos) {
+    if (!repos.length)
+        return '';
+    const list = repos.map((r) => `- \`${r.rel}\` (${r.path})`);
+    const cited = repos.filter((r) => r.cite);
+    if (role === 'write') {
+        return [
+            "The work of this lot is not only in the project's repository: it also lives in these neighbouring repositories, which are not cadence projects and are added to your directories:",
+            ...list,
+            `Work there as you do in the project's repository: test first, explicit paths, and every commit there cites the lot too (\`feat(${lot}): …\`) — the program and the review find the lot's work by those commits.${cited.map((r) => ` In \`${r.rel}\` every commit also contains \`${r.cite}\` (subject or body): the repository is shared with other projects, and a commit without it is not counted.`).join('')} Never push from any of them. Where the lot touches one, run that repository's own checks; leave it with no tracked file modified.`,
+        ].join('\n');
+    }
+    return [
+        'The work of this lot is also in these neighbouring repositories (not cadence projects); the commits that cite the lot live there as well as in the project:',
+        ...list,
+        ...cited.map((r) => `In \`${r.rel}\` only the commits that also contain \`${r.cite}\` count: the repository is shared with other projects.`),
+        `\`raf commits ${lot}\` lists them all; read the diff of the neighbouring ones with \`git -C <path> log\` / \`git -C <path> show\` (${repos.map((r) => `git -C ${r.path} log`).join(' ; ')}), and review them like the rest. You are read-only there too.`,
+    ].join('\n');
+}
 /** Consigne d'implémentation d'un lot `visible` : son entrée Nouveautés (convention de `cadence news`, voir le README). */
 export function newsText(lot, captureDir) {
     return [
@@ -49,7 +69,7 @@ export function loadTemplates(dir = TEMPLATES_DIR) {
 export function renderBrief(kind, vars, source = TEMPLATES_DIR) {
     const text = typeof source === 'string' ? loadTemplates(source)[kind] : source[kind];
     const out = text.replace(/\{\{(\w+)\}\}/g, (_m, name) => {
-        const v = vars[name];
+        const v = { ...vars, repos: vars.repos ?? '' }[name];
         if (v === undefined)
             throw new RafError(`gabarit ${FILES[kind]} : valeur manquante pour {{${name}}}`);
         return v;

package/dist/orchestrate/command.js

@@ -18,7 +18,8 @@ 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, lotSlug, newLot, RunStore } from './state.js';
+import { resolveLotRepos } from '../repos.js';
+import { excludeState, lotKey, lotRepoPaths, lotSlug, neighbourDirs, 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';
@@ -183,18 +184,26 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
             refusals.push(`${key} : dépendance(s) ni terminée(s) ni plus tôt dans la vague : ${open.join(', ')}`);
             continue;
         }
+        // Dépôts voisins du lot (L62) : chacun doit exister et être un dépôt git, sinon refus avant d'agir comme pour le dépôt du projet.
+        const neighbours = resolveLotRepos(t.repo, lot);
+        if (neighbours.problems.length) {
+            refusals.push(...neighbours.problems.map((p) => `${key} : ${p}`));
+            continue;
+        }
         byProject.set(t.project, [...earlier, t.lot]);
-        if (!repoChecked.has(t.repo)) {
-            repoChecked.add(t.repo);
-            const dirty = await trackedDirty(t.repo);
+        for (const repo of [t.repo, ...neighbours.repos.map((r) => r.path)]) {
+            if (repoChecked.has(repo))
+                continue;
+            repoChecked.add(repo);
+            const dirty = await trackedDirty(repo);
             if (dirty.length)
-                refusals.push(`${basename(t.repo)} : arbre sale, ${dirty.length} fichier(s) suivi(s) modifié(s) : ${dirty.join(', ')}`);
-            const hook = canInstallPrePush(t.repo);
+                refusals.push(`${basename(repo)} : arbre sale, ${dirty.length} fichier(s) suivi(s) modifié(s) : ${dirty.join(', ')}`);
+            const hook = canInstallPrePush(repo);
             if (hook)
-                refusals.push(`${basename(t.repo)} : ${hook}`);
-            const busy = activeLock(join(sharedStateDir(t.repo), REPO_LOCK));
+                refusals.push(`${basename(repo)} : ${hook}`);
+            const busy = activeLock(join(sharedStateDir(repo), REPO_LOCK));
             if (busy && !opts.resume)
-                refusals.push(`${basename(t.repo)} : une orchestration y est déjà en cours (${busy.wave}, pid ${busy.pid})`);
+                refusals.push(`${basename(repo)} : une orchestration y est déjà en cours (${busy.wave}, pid ${busy.pid})`);
         }
         const node = resolveNode(t.repo, nvmVersionsDir(io.env));
         if (node.kind === 'missing') {
@@ -203,6 +212,8 @@ async function preflight(args, targets, io, deps, launch, opts = {}) {
         }
         const small = lot.estimate <= 0.5 || lot.quickwin;
         const state = newLot({ project: t.project, repo: t.repo, lot: t.lot, title: lot.title, visible: lot.visible, small, model: t.model, readOnlyPlan: plan.readonly });
+        if (neighbours.repos.length)
+            state.repos = neighbours.repos;
         state.light = lot.estimate <= env.config.review.threshold;
         state.budget = lotBudget(lot.estimate);
         state.dependsOn = lot.after.filter((d) => earlier.includes(d));
@@ -243,13 +254,15 @@ function dryRun(lots, io, deps, budget, id) {
         io.out(`${lotKey(l.project, l.lot)} — ${l.title}`);
         io.out(`  budget du lot : ${l.budget} tokens comptés (dérivé de l'estimate)`);
         io.out(`  file ${basename(l.repo)} · ${slot < 2 ? `créneau ${slot + 1}` : 'en attente d\'un créneau'}`);
+        if (l.repos?.length)
+            io.out(`  dépôts voisins : ${l.repos.map((r) => r.rel).join(', ')} (verrou, garde de push et --add-dir ; leurs commits citent ${l.lot})`);
         if (l.node) {
             const sk = l.node.skipped;
             const skipped = sk?.length ? ` ; ${sk.join(', ')} ${sk.length > 1 ? 'écartées' : 'écartée'} : pas de node exécutable` : '';
             io.out(`  node : ${l.node.version} (.nvmrc ${l.node.wanted}${skipped})`);
         }
         const steps = [{ kind: 'implement', model: l.model }];
-        if (needsPrecheck(env.config, env.loadPlan(), l.repo, l.lot))
+        if (needsPrecheck(env.config, env.loadPlan(), l.repo, l.lot, l.repos))
             steps.unshift({ kind: 'precheck', model: 'sonnet' });
         const { light, full } = env.config.review;
         if (l.small)
@@ -270,7 +283,7 @@ function dryRun(lots, io, deps, budget, id) {
             const brief = renderBrief(s.kind, vars, deps.templatesDir);
             writeFileSync(file, brief);
             const playwright = !!mcpServersFor(s.kind, l.visible, '', l.small).playwright;
-            const args = buildArgs({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model, schema: schemaFor(s.kind), agent: s.kind === 'implement' ? undefined : s.kind === 'ux' ? 'ux-reviewer' : s.kind === 'precheck' ? 'precheck-reader' : 'code-reviewer', cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: playwright && (s.kind === 'implement') ? [...env.config.addDirs, pwDir] : env.config.addDirs, timeoutMs: 0, mcpConfig: '<mcp>', playwright }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
+            const args = buildArgs({ kind: s.kind, sessionId: '<uuid>', brief: '<brief>', model: s.model, schema: schemaFor(s.kind), agent: s.kind === 'implement' ? undefined : s.kind === 'ux' ? 'ux-reviewer' : s.kind === 'precheck' ? 'precheck-reader' : 'code-reviewer', cwd: l.repo, wave: id, permissionMode: env.config.permissionMode, addDirs: [...env.config.addDirs, ...(playwright && s.kind === 'implement' ? [pwDir] : []), ...neighbourDirs(l)], timeoutMs: 0, mcpConfig: '<mcp>', playwright }, agents).map((a) => (a.startsWith('{') ? '<json>' : a));
             io.out(`  ${s.kind} : claude ${args.join(' ')}`);
             io.out(`    brief : ${file}`);
             const servers = Object.keys(mcpServersFor(s.kind, l.visible, '', l.small));
@@ -458,7 +471,7 @@ async function execute(wave, lots, store, io, deps, today, cap, all = lots) {
     excludeState(launch);
     const home = cadenceHome();
     const held = [];
-    const repos = [...new Set(lots.map((l) => l.repo))];
+    const repos = [...new Set(lots.flatMap(lotRepoPaths))];
     const release = () => {
         for (const f of held)
             releaseLock(f, process.pid);
@@ -632,7 +645,7 @@ async function resume(args, argv, io, deps, launch, today) {
         live.push(l);
     }
     // Comme au départ : un dépôt tenu par une autre orchestration vivante est refusé avant toute écriture.
-    for (const repo of new Set(live.map((l) => l.repo))) {
+    for (const repo of new Set(live.flatMap(lotRepoPaths))) {
         const busy = activeLock(join(sharedStateDir(repo), REPO_LOCK));
         if (busy && busy.pid !== process.pid)
             refusals.push(`${basename(repo)} : une orchestration y est déjà en cours (${busy.wave}, pid ${busy.pid})`);
@@ -676,12 +689,12 @@ async function resume(args, argv, io, deps, launch, today) {
     if (args.budget !== undefined)
         wave.budget = wave.consumed + args.budget;
     const dirty = new Set();
-    for (const l of live)
-        if (!dirty.has(l.repo)) {
-            dirty.add(l.repo);
-            const d = await trackedDirty(l.repo);
+    for (const repo of live.flatMap(lotRepoPaths))
+        if (!dirty.has(repo)) {
+            dirty.add(repo);
+            const d = await trackedDirty(repo);
             if (d.length)
-                refusals.push(`${basename(l.repo)} : arbre sale, ${d.length} fichier(s) suivi(s) modifié(s) : ${d.join(', ')}`);
+                refusals.push(`${basename(repo)} : arbre sale, ${d.length} fichier(s) suivi(s) modifié(s) : ${d.join(', ')}`);
         }
     if (refusals.length) {
         for (const r of refusals)

package/dist/orchestrate/cycle.js

@@ -6,14 +6,15 @@ import { writeFileSync } from 'node:fs';
 import { lotCommits, lotWork } from '../audit.js';
 import { readCommits, resolveCommit } from '../git.js';
 import { citedRefs } from '../link.js';
+import { repoShas, repoWork } from '../repos.js';
 import { isOpen } from '../plan.js';
 import { isPlanOnly } from '../audit.js';
 import { APP_TIMEOUT_S, startApp } from './app.js';
-import { capturesText, newsText, objective, renderBrief } from './briefs.js';
+import { capturesText, newsText, objective, renderBrief, reposText } 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';
+import { lotKey, neighbourDirs } from './state.js';
 /** Passes de correction au plus, puis la main est rendue au lead. */
 export const MAX_PASSES = 2;
 export class Budget {
@@ -152,7 +153,13 @@ async function startLot(c) {
 }
 function lotCommitLines(c) {
     const plan = c.loadPlan();
-    return lotWork(plan, c.lot.repo, c.lot.lot).reverse().map((k) => `- ${short(k)}`).join('\n');
+    const mine = lotWork(plan, c.lot.repo, c.lot.lot).reverse().map((k) => `- ${short(k)}`);
+    const theirs = (c.lot.repos ?? []).flatMap((r) => repoWork(plan, r, c.lot.lot).reverse().map((k) => `- [${r.rel}] ${short(k)}`));
+    return [...mine, ...theirs].join('\n');
+}
+/** Le lot a déjà du travail (commits citant le lot) dans son dépôt ou dans un dépôt voisin. */
+function hasWork(plan, l) {
+    return lotWork(plan, l.repo, l.lot).length > 0 || (l.repos ?? []).some((r) => repoWork(plan, r, l.lot).length > 0);
 }
 function constatLines(constats) {
     return constats
@@ -203,7 +210,7 @@ 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 ?? []), checks: kind === 'review' || kind === 'review-small' ? checksText(c) : '', news: '', captures: '' };
+    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: '', repos: reposText(kind === 'implement' || kind === 'fix' ? 'write' : 'read', l.lot, l.repos ?? []) };
     if (l.visible) {
         const pwDir = playwrightDir(c.wave.store.lotDir(l.project, l.lot));
         vars.news = newsText(l.lot, pwDir);
@@ -259,6 +266,8 @@ async function session(c, kind) {
     const write = kind === 'implement' || kind === 'fix';
     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 neighbours = l.repos ?? [];
+    const beforeOthers = await Promise.all(neighbours.map((r) => snapshot(r.path)));
     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 };
@@ -290,7 +299,7 @@ async function session(c, kind) {
         cwd: l.repo,
         wave: w.id,
         permissionMode: c.config.permissionMode,
-        addDirs: playwright && write ? [...c.config.addDirs, playwrightDir(dirname(mcpConfig))] : c.config.addDirs,
+        addDirs: [...c.config.addDirs, ...(playwright && write ? [playwrightDir(dirname(mcpConfig))] : []), ...neighbourDirs(l)],
         nodeBin: l.node?.link,
         toolBin: toolBinOf(w.store.dir),
         mcpConfig,
@@ -357,31 +366,37 @@ async function session(c, kind) {
     if (w.claudeHome)
         step.peakContext = peakContext(w.claudeHome, l.repo, res.sessionId);
     const after = await snapshot(l.repo);
+    const afterOthers = await Promise.all(neighbours.map((r) => snapshot(r.path)));
+    const others = neighbours.map((repo, i) => ({ repo, before: beforeOthers[i], after: afterOthers[i] }));
     step.headAfter = after.head ?? undefined;
-    if (pushed(before, after)) {
-        step.status = 'failed';
-        step.cause = 'push détecté';
-        w.incident = `push détecté pendant ${lotKey(l.project, l.lot)} (${kind})`;
-        w.saveWave();
-        return stop(c, 'failed', `incident : ${w.incident}`);
-    }
-    if (before.guard && !after.guard) {
-        step.status = 'failed';
-        step.cause = 'le hook pre-push de garde a disparu';
-        w.incident = `le hook pre-push de garde a été supprimé pendant ${lotKey(l.project, l.lot)} (${kind})`;
-        w.saveWave();
-        return stop(c, 'failed', `incident : ${w.incident}`);
-    }
-    if (!write && (before.head !== after.head || before.tracked.join() !== after.tracked.join() || before.untracked.join() !== after.untracked.join())) {
-        step.status = 'failed';
-        step.cause = 'le dépôt a changé pendant une revue';
-        w.incident = `${kind} de ${lotKey(l.project, l.lot)} a modifié le dépôt`;
-        w.saveWave();
-        return stop(c, 'failed', `incident : ${w.incident}`);
+    // Le dépôt du projet d'abord, puis chaque voisin : mêmes contrôles, l'incident nomme le dépôt voisin.
+    const watched = [{ where: '', before, after }, ...others.map((o) => ({ where: ` dans ${o.repo.rel}`, before: o.before, after: o.after }))];
+    for (const { where, before: b, after: a } of watched) {
+        if (pushed(b, a)) {
+            step.status = 'failed';
+            step.cause = `push détecté${where}`;
+            w.incident = `push détecté${where} pendant ${lotKey(l.project, l.lot)} (${kind})`;
+            w.saveWave();
+            return stop(c, 'failed', `incident : ${w.incident}`);
+        }
+        if (b.guard && !a.guard) {
+            step.status = 'failed';
+            step.cause = `le hook pre-push de garde a disparu${where}`;
+            w.incident = `le hook pre-push de garde a été supprimé${where} pendant ${lotKey(l.project, l.lot)} (${kind})`;
+            w.saveWave();
+            return stop(c, 'failed', `incident : ${w.incident}`);
+        }
+        if (!write && (b.head !== a.head || b.tracked.join() !== a.tracked.join() || b.untracked.join() !== a.untracked.join())) {
+            step.status = 'failed';
+            step.cause = `le dépôt${where} a changé pendant une revue`;
+            w.incident = `${kind} de ${lotKey(l.project, l.lot)} a modifié le dépôt${where}`;
+            w.saveWave();
+            return stop(c, 'failed', `incident : ${w.incident}`);
+        }
     }
     step.status = 'ok';
     save(c);
-    return { step, report: res.structured, before, after };
+    return { step, report: res.structured, before, after, others };
 }
 /** 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) {
@@ -394,12 +409,12 @@ function suspend(c, why) {
     transition(c, 'suspended', why);
     return null;
 }
-function summarize(rep, head) {
+function summarize(rep, head, repoHeads) {
     // Rien d'un rapport n'est cru sur parole : un constat de gravité majeure compte même si les totaux annoncés disent 0.
     const count = (g) => rep.constats.filter((k) => k.gravite === g).length;
     const bloquants = Math.max(rep.bloquants, count('bloquant'));
     const majeurs = Math.max(rep.majeurs, count('majeur'));
-    return { conforme: bloquants === 0 && majeurs === 0, bloquants, majeurs, mineurs: Math.max(rep.mineurs, count('mineur')), verdict: rep.verdict.trim(), sousTaches: rep.sousTaches, nonVerifie: rep.nonVerifie, head };
+    return { conforme: bloquants === 0 && majeurs === 0, bloquants, majeurs, mineurs: Math.max(rep.mineurs, count('mineur')), verdict: rep.verdict.trim(), sousTaches: rep.sousTaches, nonVerifie: rep.nonVerifie, head, ...(repoHeads ? { repoHeads } : {}) };
 }
 function propose(c, text) {
     if (!c.lot.proposals.includes(text))
@@ -426,8 +441,8 @@ function badReport(c, step, e) {
     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;
+export function needsPrecheck(config, plan, repo, lot, repos = []) {
+    return config.precheck && !hasWork(plan, { repo, repos, lot });
 }
 /**
  * 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
@@ -484,9 +499,12 @@ async function work(c, kind) {
     const plan = c.loadPlan();
     const range = done.step.headBefore ? `${done.step.headBefore}..HEAD` : undefined;
     const commits = readCommits(l.repo, { range });
-    done.step.commits = commits.map(short).reverse();
+    // Commits de la session dans chaque dépôt voisin (L62) : de la tête d'avant la session à la tête d'après.
+    const theirs = done.others.map((o) => ({ repo: o.repo, commits: o.before.head ? readCommits(o.repo.path, { range: `${o.before.head}..HEAD` }) : [] }));
+    const made = commits.length + theirs.reduce((n, t) => n + t.commits.length, 0);
+    done.step.commits = [...commits.map(short).reverse(), ...theirs.flatMap((t) => t.commits.map((k) => `[${t.repo.rel}] ${short(k)}`).reverse())];
     // La liste de git fait foi ; l'écart avec celle du rapport est signalé.
-    const real = new Set(commits.map((k) => k.sha));
+    const real = new Set([...commits, ...theirs.flatMap((t) => t.commits)].map((k) => k.sha));
     for (const a of rep.commits) {
         if ([...real].some((s) => s.startsWith(a.sha) || a.sha.startsWith(s.slice(0, 7))))
             continue;
@@ -502,6 +520,11 @@ async function work(c, kind) {
         if (!citedRefs(k, plan.refs).some((r) => r.lot === l.lot))
             l.warnings.push(`commit qui ne cite pas ${l.lot} : ${short(k)}`);
     }
+    for (const t of theirs) {
+        for (const k of t.commits)
+            if (!citedRefs(k, plan.refs).some((r) => r.lot === l.lot))
+                l.warnings.push(`commit qui ne cite pas ${l.lot} dans ${t.repo.rel} : ${short(k)}`);
+    }
     save(c);
     for (const x of rep.choix ?? [])
         if (!(l.choix ??= []).includes(x))
@@ -522,7 +545,11 @@ async function work(c, kind) {
         transition(c, 'question', questions[0]);
         return;
     }
-    const dirt = [...trackedPaths(done.after), ...done.after.untracked.filter((f) => !done.before.untracked.includes(f))];
+    const dirt = [
+        ...trackedPaths(done.after),
+        ...done.after.untracked.filter((f) => !done.before.untracked.includes(f)),
+        ...done.others.flatMap((o) => [...trackedPaths(o.after), ...o.after.untracked.filter((f) => !o.before.untracked.includes(f))].map((f) => `${o.repo.rel}: ${f}`)),
+    ];
     if (dirt.length) {
         stop(c, 'handed-back', `dépôt sale après ${kind} : ${dirt.join(', ')}`);
         return;
@@ -535,8 +562,8 @@ async function work(c, kind) {
             break;
         resumedFrom = s.headBefore;
     }
-    const headMoved = kind === 'fix' && commits.length === 0 && !!resumedFrom && git(l.repo, 'rev-parse', 'HEAD') !== resumedFrom;
-    if (minorsPass && commits.length === 0 && !headMoved) {
+    const headMoved = kind === 'fix' && made === 0 && !!resumedFrom && git(l.repo, 'rev-parse', 'HEAD') !== resumedFrom;
+    if (minorsPass && made === 0 && !headMoved) {
         // Rien à corriger (mineurs jugés faux, listés en « choix ») : la revue conforme d'origine vaut, HEAD n'a pas bougé.
         for (const k of l.constats.filter((k) => k.gravite === 'mineur'))
             propose(c, minorLine('code', k));
@@ -550,14 +577,14 @@ 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 = lotWork(plan, l.repo, l.lot).length > 0;
-    if (commits.length === 0 && !alreadyDone && !headMoved) {
+    const alreadyDone = hasWork(plan, l);
+    if (made === 0 && !alreadyDone && !headMoved) {
         stop(c, 'handed-back', `${kind} sans commit`);
         return;
     }
     if (headMoved)
         l.warnings.push(`${minorsPass ? 'passe des mineurs' : 'correction'} reprise sans nouveau commit : un commit d'une session précédente est relu par la revue`);
-    else if (commits.length === 0)
+    else if (made === 0)
         l.warnings.push(kind === 'fix' ? 'fix sans nouveau commit : revue lancée sur les commits du lot' : `${kind} sans nouveau commit : revue lancée sur les commits déjà faits du lot`);
     const red = [];
     if (!rep.tests.vert)
@@ -678,7 +705,7 @@ async function reviewStep(c, kind) {
         badReport(c, done.step, e);
         return;
     }
-    const summary = summarize(rep, done.after.head ?? '');
+    const summary = summarize(rep, done.after.head ?? '', done.others.length ? Object.fromEntries(done.others.map((o) => [o.repo.rel, o.after.head ?? ''])) : undefined);
     if (kind === 'ux') {
         l.ux = summary;
         addProposals(c, rep, 'ux');
@@ -747,16 +774,21 @@ function uxConstatsKept(c) {
 async function conclude(c, code, minorNote = '') {
     const l = c.lot;
     const plan = c.loadPlan();
-    const verdict = `${code.verdict} — orchestré (vague ${c.wave.id}, ${l.pass} passe(s) de correction${l.minorPass ? ` + passe des mineurs${minorNote}` : ''})`;
+    // Dépôts voisins du lot (L62) : le sha lu de chacun est enregistré avec le verdict, et dit dans son texte (un plan en lecture seule n'a que le texte).
+    const neighbours = l.repos ?? [];
+    const shas = repoShas(plan, neighbours, l.lot);
+    const read = neighbours.length ? ` ; dépôts relus : ${neighbours.map((r) => `${r.rel}@${shas[r.rel]?.slice(0, 7) ?? 'aucun commit du lot'}`).join(', ')}` : '';
+    const verdict = `${code.verdict} — orchestré (vague ${c.wave.id}, ${l.pass} passe(s) de correction${l.minorPass ? ` + passe des mineurs${minorNote}` : ''}${read})`;
     l.verdict = verdict;
     const newer = lotWork(plan, l.repo, l.lot)[0]?.sha ?? null;
-    if (code.head && newer !== null && git(l.repo, 'rev-parse', 'HEAD') !== code.head) {
-        stop(c, 'handed-back', 'un commit est postérieur à la revue : verdict non enregistré');
+    const moved = (code.head && newer !== null && git(l.repo, 'rev-parse', 'HEAD') !== code.head ? [''] : []).concat(neighbours.filter((r) => shas[r.rel] !== null && code.repoHeads?.[r.rel] && git(r.path, 'rev-parse', 'HEAD') !== code.repoHeads[r.rel]).map((r) => ` dans ${r.rel}`));
+    if (moved.length) {
+        stop(c, 'handed-back', `un commit est postérieur à la revue${moved.join(',')} : verdict non enregistré`);
         return;
     }
     l.constats = [];
     if (!plan.readonly) {
-        plan.recordReview(l.lot, verdict, c.wave.today, newer);
+        plan.recordReview(l.lot, verdict, c.wave.today, newer, neighbours.length ? shas : undefined);
         plan.save();
         const dirty = await commitPlan(c, `plan: ${l.lot} revue de code enregistrée (orchestrate ${c.wave.id})`);
         if (dirty) {
@@ -825,7 +857,7 @@ export async function runLot(c) {
                 return;
             }
             l.startedSha = (await snapshot(l.repo, { remote: false })).head ?? undefined;
-            l.next = needsPrecheck(c.config, c.loadPlan(), l.repo, l.lot) ? 'precheck' : 'implement';
+            l.next = needsPrecheck(c.config, c.loadPlan(), l.repo, l.lot, l.repos) ? 'precheck' : 'implement';
             save(c);
         }
         while (l.next && !TERMINAL.has(l.status)) {

package/dist/orchestrate/pool.js

@@ -1,17 +1,31 @@
 import { runLot } from './cycle.js';
-import { lotKey } from './state.js';
+import { lotKey, lotRepoPaths } from './state.js';
 /** Valeur de repli de `runPool` quand l'appelant ne donne pas de plafond ; le réglage réel est DEFAULT_MAX_SESSIONS, `--max-sessions` ou CADENCE_MAX_SESSIONS (command.ts). */
 export const SLOTS = 2;
 /**
  * Ordonnanceur : une file par dépôt, les lots d'un dépôt l'un après l'autre dans l'ordre donné, `slots` dépôts
- * au plus en parallèle (le plafond global des sessions de toutes
+ * au plus en parallèle. Deux lots qui partagent un dépôt (le leur, ou un dépôt voisin déclaré par `repos:`, L62) sont dans la
+ * même file : jamais deux sessions dans un même dépôt (le plafond global des sessions de toutes
  * les vagues est tenu par command.ts). Le budget, le quota et les incidents sont vérifiés par le cycle avant chaque session.
  */
 export async function runPool(ctxs, slots = SLOTS, known = []) {
-    const queues = new Map();
-    for (const c of ctxs)
-        queues.set(c.lot.repo, [...(queues.get(c.lot.repo) ?? []), c]);
-    const pending = [...queues.values()];
+    const groups = [];
+    for (const c of ctxs) {
+        const mine = lotRepoPaths(c.lot);
+        const hit = groups.filter((g) => mine.some((r) => g.repos.has(r)));
+        const group = hit[0] ?? { repos: new Set(), lots: [] };
+        if (!hit.length)
+            groups.push(group);
+        for (const other of hit.slice(1)) {
+            other.repos.forEach((r) => group.repos.add(r));
+            group.lots.push(...other.lots);
+            groups.splice(groups.indexOf(other), 1);
+        }
+        mine.forEach((r) => group.repos.add(r));
+        group.lots.push(c);
+        group.lots.sort((x, y) => ctxs.indexOf(x) - ctxs.indexOf(y));
+    }
+    const pending = groups.map((g) => g.lots);
     const worker = async () => {
         for (let queue = pending.shift(); queue; queue = pending.shift()) {
             // Un lot en attente est revisité tant qu'un tour de la file en fait avancer un autre (sa dépendance peut venir après lui).

package/dist/orchestrate/state.js

@@ -4,6 +4,10 @@ import { gitCommonDir, gitRoot } from '../git.js';
 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 };
 }
+/** Tous les dépôts où les sessions du lot travaillent : celui du projet, puis ses voisins. */
+export const lotRepoPaths = (l) => [l.repo, ...(l.repos ?? []).map((r) => r.path)];
+/** Les dépôts voisins du lot, donnés en `--add-dir` à ses sessions. */
+export const neighbourDirs = (l) => (l.repos ?? []).map((r) => r.path);
 export const lotKey = (project, lot) => `${project}:${lot}`;
 /** 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('__')}`;

package/dist/plan.js

@@ -5,7 +5,7 @@ import { isDay, toDay } from './dates.js';
 export const STATUSES = ['todo', 'doing', 'done', 'dropped'];
 export class RafError extends Error {
 }
-export const FIELDS = ['id', 'title', 'status', 'estimate', 'quickwin', 'visible', 'public', 'every', 'last', 'after', 'created', 'started', 'finished', 'notes', 'parent'];
+export const FIELDS = ['id', 'title', 'status', 'estimate', 'quickwin', 'visible', 'public', 'every', 'last', 'after', 'created', 'started', 'finished', 'notes', 'repos', 'parent'];
 export function isOpen(status) {
     return status === 'todo' || status === 'doing';
 }
@@ -231,8 +231,8 @@ export class Plan {
         return this.enableGate('reviewSince', today);
     }
     /** `commit` : sha du dernier commit compté du lot (le plan ne lit pas git), null s'il n'en a aucun. */
-    recordReview(lotId, verdict, today, commit) {
-        this.recordVerdict('review', 'la revue de code', lotId, { date: today, verdict, commit });
+    recordReview(lotId, verdict, today, commit, repos) {
+        this.recordVerdict('review', 'la revue de code', lotId, { date: today, verdict, commit, ...(repos && Object.keys(repos).length ? { repos } : {}) });
     }
     enableGate(key, today) {
         this.writable();
@@ -469,6 +469,7 @@ function foreignLots(raw, format) {
             started: day('started'),
             finished: day('finished'),
             notes: typeof notes === 'string' ? [{ text: notes }] : notes,
+            repos: pick('repos'),
         }, problems);
         const parent = pick('parent');
         return { lot, parent: parent == null ? undefined : String(parent) };
@@ -531,11 +532,28 @@ function normalizeLot(raw, problems = []) {
                 status: STATUSES.includes(t.status) ? t.status : 'todo',
             }))
             : [],
+        ...(repoList(raw.repos).length ? { repos: repoList(raw.repos) } : {}),
         ...(asVerdict(raw.ux) ? { ux: asVerdict(raw.ux) } : {}),
         ...(asVerdict(raw.review) ? { review: asVerdict(raw.review) } : {}),
         problems,
     };
 }
+/**
+ * Dépôts voisins déclarés : une chaîne (le chemin) ou un objet `{ path, cite }`, seuls ou en liste (une valeur seule vaut une
+ * liste d'un dépôt). Une entrée sans chemin textuel est écartée ; un `cite` vide ou non textuel vaut pas de `cite`.
+ */
+function repoList(raw) {
+    const items = Array.isArray(raw) ? raw : raw == null ? [] : [raw];
+    const out = [];
+    for (const item of items) {
+        const path = typeof item === 'string' ? item : item && typeof item === 'object' && typeof item.path === 'string' ? item.path : '';
+        if (path.trim() === '')
+            continue;
+        const cite = item && typeof item === 'object' ? item.cite : undefined;
+        out.push({ path: path.trim(), ...(typeof cite === 'string' && cite.trim() !== '' ? { cite: cite.trim() } : {}) });
+    }
+    return out;
+}
 function asVerdict(raw) {
     if (!raw || typeof raw !== 'object')
         return undefined;
@@ -548,5 +566,10 @@ function asVerdict(raw) {
     // Champ présent mais vide : relu « jusqu'à rien », comme un verdict noté sans commit.
     if ('commit' in v)
         verdict.commit = v.commit == null || String(v.commit).trim() === '' ? null : String(v.commit).trim();
+    if (v.repos && typeof v.repos === 'object' && !Array.isArray(v.repos)) {
+        const repos = Object.entries(v.repos).map(([k, sha]) => [k, sha == null || String(sha).trim() === '' ? null : String(sha).trim()]);
+        if (repos.length)
+            verdict.repos = Object.fromEntries(repos);
+    }
     return verdict;
 }