@sylad/cadence 0.15.0 → 0.16.0

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "cadence",
       "description": "Session start and close rituals driven by a versioned plan (raf), and deliveries proven by their effect. Needs the cadence CLI (npm i -g @sylad/cadence).",
-      "version": "0.15.0",
+      "version": "0.16.0",
       "source": "./",
       "author": {
         "name": "Sylvain Ladoire"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cadence",
   "description": "A repo-native working method: session start and close rituals driven by a versioned plan (raf), deliveries proven by their effect, and three reviewer agents (UX, code, QA).",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "author": { "name": "Sylvain Ladoire" },
   "homepage": "https://github.com/Sylad/cadence",
   "repository": "https://github.com/Sylad/cadence",

package/README.md

@@ -24,7 +24,7 @@ Code prompt that shows the session's context, quota, cost and the orchestrate wa
 
 ## What's new
 
-**0.15.0**: `hook.autostart` in `cadence.yaml` (`warn` by default, `refuse` or `start`): a pre-commit hook that refuses, or starts in the same commit, a lot still todo that the commit cites; `cadence session start|close --all [--depth n]`, one section per project under a folder. **0.14.0**: `cadence lead tour`, the lead's morning table of every project in a folder, printed by a program (one line per project: lots in progress, gaps, last notes, next ready lot, repository) in place of one subagent per project; the `lead` skill calls it. **0.13.1**: `cadence-hud` takes back the segments that fit once a big one has dropped (reset times, then the per-model consumption, now short: `opus 1.2M sonnet 800k`); `CADENCE_HUD_AMBIGUOUS=1` for a terminal that draws `▰ ▱ ⚙ │ ↻` in one cell. **0.13.0**: `cadence orchestrate --status --watch` (a wave's table redrawn in the terminal, which
+**0.16.0**: a lot can declare **neighbouring repositories** (`repos:` key of the lot, `{ path, cite }` for a repository shared between projects): `cadence orchestrate` refuses, locks and guards them, gives them to every session as `--add-dir`, and `raf commits`, `raf show` and the review verdict read the commits that cite the lot there too. **0.15.0**: `hook.autostart` in `cadence.yaml` (`warn` by default, `refuse` or `start`): a pre-commit hook that refuses, or starts in the same commit, a lot still todo that the commit cites; `cadence session start|close --all [--depth n]`, one section per project under a folder. **0.14.0**: `cadence lead tour`, the lead's morning table of every project in a folder, printed by a program (one line per project: lots in progress, gaps, last notes, next ready lot, repository) in place of one subagent per project; the `lead` skill calls it. **0.13.1**: `cadence-hud` takes back the segments that fit once a big one has dropped (reset times, then the per-model consumption, now short: `opus 1.2M sonnet 800k`); `CADENCE_HUD_AMBIGUOUS=1` for a terminal that draws `▰ ▱ ⚙ │ ↻` in one cell. **0.13.0**: `cadence orchestrate --status --watch` (a wave's table redrawn in the terminal, which
 stops with the wave) and the lead skill that names the wave and follows its journal; lot ids with `/`
 (sub-tasks of a read-only plan) accepted by `orchestrate`; `cadence-hud`'s first line measured in
 terminal cells and kept to ASCII; `publish.yml` on the v5 actions. **0.12.0**: the `cadence-hud` plugin (a status band above the Claude Code prompt),
@@ -91,8 +91,8 @@ raf gantt                         # docs/plan/gantt.html
 | `raf public <id> "title"` · `raf public <id> --clear` | set, replace or remove the public title of a lot |
 | `raf start <id>` · `raf done <id> [--force]` · `raf drop <id> [--reason text]` | dated transitions (`done` refuses open sub-tasks unless `--force`) |
 | `raf note <id> "text"` | dated note — keep decisions next to the work |
-| `raf show <id> [--notes]` | one lot: status, dates, `after`, public title, dated notes in order, then the counted commits (as `raf commits`); `--notes` prints the notes alone |
-| `raf commits <id>` | the commits counted for a lot (the set the code review gate uses), one `<sha> <subject>` per line, oldest first |
+| `raf show <id> [--notes]` | one lot: status, dates, `after`, public title, dated notes in order, then the counted commits (as `raf commits`, neighbouring repositories included); `--notes` prints the notes alone |
+| `raf commits <id>` | the commits counted for a lot (the set the code review gate uses), one `<sha> <subject>` per line, oldest first; a lot that declares `repos:` ([neighbouring repositories](#a-lot-whose-work-is-in-a-neighbouring-repository)) gets, after them, one `dépôt <path> :` section per neighbour with the commits there that cite the lot and fall within the lot's period (`started` to `finished`) and, when the lot declares a `cite:` for that neighbour, contain that string (`aucun commit du lot`, or `introuvable` for a path that is not there) |
 | `raf now` | what to do next |
 | `raf list [--status s]` | flat list |
 | `raf ignore <sha> \| "exact subject" [--reason text]` | acknowledge a commit without a lot (tooling chore, a plan commit citing an unknown id) without rewriting history: a dated, reasoned line in the plan's `acknowledged:` section; a sha is exact, a subject covers every commit carrying it |
@@ -195,6 +195,7 @@ plan:
     started: demarre_le
     finished: [livre_le, ferme_le]
     notes: note
+    repos: depots               # the lot's neighbouring repositories (a list of paths and/or { path, cite }, or one of them)
     parent: parent
   statuses:                     # raf status: their states
     todo: [prevu, specifie]
@@ -205,7 +206,7 @@ plan:
 ```
 
 - Fields: `id`, `title`, `status`, `estimate`, `quickwin`, `visible`, `public`, `every`, `last`, `after`, `created`, `started`,
-  `finished`, `notes`, `parent`; one left out is read under its own name. A timestamp counts for
+  `finished`, `notes`, `repos`, `parent`; one left out is read under its own name. A timestamp counts for
   its day; a note written as plain text is one note.
 - `parent`: an entry `B33/t1-fusion` whose parent is `B33` becomes the sub-task `t1-fusion` of `B33`.
 - Ids need no prefix: a commit belongs to a lot when its message cites one of the plan's ids as a
@@ -334,6 +335,12 @@ written by hand without a `commit` field is not checked for staleness. An empty
 verdict is refused, and one left empty or blank by hand in the YAML counts as no
 review. Plans without `reviewSince` are not affected.
 
+A lot that works in neighbouring repositories (`repos:`, see [orchestrate](#a-lot-whose-work-is-in-a-neighbouring-repository))
+has its verdict tied to each of them: `raf review` also stores, under `repos`, the sha of the latest counted commit of the
+lot in each neighbour (the one `raf commits` lists last: it cites the lot, falls within the lot's period and contains the `cite:` string if any) (`review: { date, verdict, commit, repos: { ../aetherwx-gitops: <sha> } }`, `null` when a
+neighbour has none), and refuses to record when a listed repository cannot be read. `raf check` does not audit the
+neighbours: their staleness is not checked, only the project's own commits are.
+
 ### QA review
 
 No gate and no command here: the QA review comes **after** a delivery, and
@@ -818,6 +825,60 @@ The sessions of the wave also get `.cadence/runs/<wave>/tool/bin` (the `raf` and
 `PATH`**, ahead of the per-project Node below and of the usual `PATH`: the `raf` a reviewer runs (`raf commits`…) is the
 snapshot's, not the installed one. A wave without a snapshot leaves the `PATH` as it is.
 
+### A lot whose work is in a neighbouring repository
+
+Some lots are done in another repository that is not a cadence project (B64 of `maritime-atlas` lives in
+`aetherwx-gitops`, a Helm chart repository). The lot declares it with the **lot key `repos:`** — a list of paths relative to
+the project's repository, one path being enough as a string. There is no project-wide key: a neighbour belongs to a lot.
+
+```yaml
+lots:
+  - id: B64
+    title: …
+    repos: [../aetherwx-gitops]
+```
+
+**Which commits count in a neighbour.** Nothing is inferred from the neighbour or from the project's name. A commit counts
+when it cites the lot's id (as in the project: `feat(B64): …`, `maritime: … (B64)`) **and** is dated within the lot's period,
+`started` to `finished` (an open end is open). That is all, whatever the prefix or scope of the subject says and whatever
+the commit mentions. When a neighbour is shared between projects whose lots share an id prefix (`developpeur-gitops` holds
+the charts of `finance-tracker`, `warhammer40k` and `ol-companion`, all `L…`), the lot says so with an **explicit key**: an
+entry of `repos:` can be an object, and the list can mix both forms.
+
+```yaml
+    repos:
+      - ../aetherwx-gitops                                  # id + period
+      - { path: ../developpeur-gitops, cite: ol-companion } # id + period + this string
+```
+
+With `cite`, a commit must also contain that string (a substring, case-insensitive, searched in the subject and the body);
+a commit of another app that cites the same id is dropped from `raf commits`, from the briefs, from the sha a review
+records and from the orchestrator's « already has work » test. Without `cite`, in a shared neighbour, the commits of the
+other apps that cite the same id **do** count: that is the default, so declare `cite` for such a neighbour. `cite` applies
+to the neighbour it is written on, not to the project's own repository. The commits of the lot in the neighbour must carry the
+string too (the briefs say so); one that does not is not counted.
+
+A read-only plan declares it in `cadence.yaml` with `plan.fields.repos: <the file's key>` (a left-out field is read under
+the name `repos`). The effect, for `cadence orchestrate`:
+
+- **Preconditions** (refused before acting, exit code 2, like the project's own repository): every listed path exists and
+  is inside a git repository, has no tracked file modified, has no `pre-push` hook of its own, and is not held by another
+  live orchestration. `--dry-run` applies the same refusals and prints `dépôts voisins : <paths>`. The project's own
+  repository and a duplicate listed twice are counted once.
+- **Lock and guard**: the neighbour gets the repository lock (`orchestrate.lock`, so `cadence deliver` refuses it too, and no
+  other wave can hold it), the temporary `pre-push` hook, and the same after-session checks (push, tampered hook, a review
+  that changed it). Two lots that share a repository, as project or as neighbour, run one after the other, never two
+  sessions in one repository; `--status` lists the neighbours among the repositories a wave holds.
+- **Sessions**: every session gets each neighbour as `--add-dir`, and the briefs name them: the implementation and the
+  corrections must commit there too, with a message that cites the lot (`feat(B64): …`), and never push; the reviewers read
+  the commits that cite the lot in the project **and** in each neighbour (`raf commits <lot>` lists them all; in a neighbour only the commits that cite the lot and are dated within the lot's period count, and also contain the `cite:` string when the lot declares one for it — a `fix(B64): …` outside the period, or one without the `cite:` string, is not listed.) A lot whose
+  whole work is in the neighbour is not « without commit »; a commit there that does not cite the lot is a warning; a
+  neighbour left with a tracked file modified hands the lot back.
+- **Verdict**: `raf review` as recorded by the orchestrator stores the sha read in the project and in each neighbour
+  (`review.repos`), and the verdict text ends with `dépôts relus : <path>@<sha>`. A commit made in a neighbour after the
+  review hands the lot back, like one in the project.
+- **Out of scope**: `raf check` does not audit the neighbours, and their delivery (push, CI, deploy) stays with the lead.
+
 **What stays with you**: choosing the lots, the questions raised (`--resume --answer`), re-verifying
 after the wave (`git log`, tests, `raf check`), `raf done`, **`raf ux`** (the orchestrator reports the UX
 verdict and screenshots, it does not record it), the push and the deliveries, one project at a time.

package/dist/cli.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
 import { readHookConfig, readNewsConfig, readPlanConfig, readSessionConfig } from './config.js';
+import { repoSections, repoShas, resolveLotRepos } from './repos.js';
 import { audit, exemptPlanOnly, ownFiles, isPlanOnly, lotWork, nextUp, planCommits, unreviewedWork } from './audit.js';
 import { short } from './check.js';
 import { isDay, toDay } from './dates.js';
@@ -290,6 +291,8 @@ function dispatch(argv, io) {
             // Une lecture : le même ensemble que « raf done » et « raf check », plan en lecture seule compris.
             for (const c of lotWork(plan, root, id).reverse())
                 io.out(short(c));
+            for (const line of repoSections(plan, root, plan.lot(id)))
+                io.out(line);
             return 0;
         }
         case 'show': {
@@ -320,6 +323,8 @@ function dispatch(argv, io) {
             io.out(`commits (${commits.length}) :`);
             for (const c of commits)
                 io.out(`  ${short(c)}`);
+            for (const line of repoSections(plan, root, lot, '  '))
+                io.out(line);
             return 0;
         }
         case 'list': {
@@ -485,8 +490,13 @@ function gate(kind, rest, loadPlan, root, today, io) {
     if (kind === 'ux')
         plan.recordUx(rest[0], verdict, today);
     // Le verdict vaut jusqu'au dernier commit compté du lot ; un plan en lecture seule refuse sans lire git.
-    else
-        plan.recordReview(rest[0], verdict, today, plan.readonly ? null : (lotWork(plan, root, rest[0])[0]?.sha ?? null));
+    else {
+        // Les dépôts voisins du lot : un dépôt qu'on ne peut pas lire ferait enregistrer un verdict sur un sha non lu.
+        const neighbours = plan.readonly || rest[0].includes('/') ? undefined : resolveLotRepos(root, plan.lots().find((l) => l.id === rest[0]) ?? {});
+        if (neighbours?.problems.length)
+            throw new RafError(`${neighbours.problems.join(' ; ')} — la revue de code relit aussi les dépôts du lot`);
+        plan.recordReview(rest[0], verdict, today, plan.readonly ? null : (lotWork(plan, root, rest[0])[0]?.sha ?? null), neighbours?.repos.length ? repoShas(plan, neighbours.repos, rest[0]) : undefined);
+    }
     plan.save();
     return 0;
 }

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;
 }

package/dist/repos.js

@@ -0,0 +1,72 @@
+import { existsSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { lotWork } from './audit.js';
+import { gitRoot } from './git.js';
+/**
+ * Résout les dépôts voisins d'un lot depuis le dossier du projet (la racine de son dépôt). Chaque chemin doit exister et
+ * être dans un dépôt git ; un doublon, ou le dépôt du projet lui-même, n'est compté qu'une fois (le second est ignoré sans bruit).
+ * Les chemins qui ne vont pas sont rendus en `problems`, à refuser avant d'agir.
+ */
+export function resolveLotRepos(base, lot) {
+    const repos = [];
+    const failures = [];
+    const own = gitRoot(base) ?? resolve(base);
+    for (const { path: rel, cite } of lot.repos ?? []) {
+        const dir = resolve(base, rel);
+        if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+            failures.push({ rel, why: `dossier introuvable (${dir})` });
+            continue;
+        }
+        const root = gitRoot(dir);
+        if (!root) {
+            failures.push({ rel, why: `${dir} n'est pas dans un dépôt git` });
+            continue;
+        }
+        if (root === own || repos.some((r) => r.path === root))
+            continue;
+        repos.push({ rel, path: root, ...(cite ? { cite } : {}) });
+    }
+    return { repos, failures, problems: failures.map((f) => `dépôt voisin ${f.rel} : ${f.why}`) };
+}
+/**
+ * Commits à relire du lot dans un dépôt voisin, du plus récent au plus ancien : ceux qui citent le lot, selon les références
+ * du plan, et tombent dans la période du lot (de son démarrage à sa fin). Rien n'est déduit du dépôt ni du nom du projet. Pour un
+ * voisin partagé entre projets, le lot déclare `cite` : le commit doit en plus contenir cette chaîne (sous-chaîne, sans tenir
+ * compte de la casse, dans le sujet et le corps). Sans `cite`, les commits d'une autre application qui citent le même id comptent.
+ */
+export function repoWork(plan, repo, lotId) {
+    const lot = plan.lots().find((l) => l.id === lotId);
+    const inPeriod = lotWork(plan, repo.path, lotId).filter((c) => (!lot?.started || c.day >= lot.started) && (!lot?.finished || c.day <= lot.finished));
+    if (!repo.cite)
+        return inPeriod;
+    const needle = repo.cite.toLowerCase();
+    return inPeriod.filter((c) => `${c.subject}\n${c.body}`.toLowerCase().includes(needle));
+}
+/** Sha du dernier commit du lot de chaque dépôt voisin (null : aucun), sous le chemin déclaré — ce qu'un verdict de revue enregistre. */
+export function repoShas(plan, repos, lotId) {
+    return Object.fromEntries(repos.map((r) => [r.rel, repoWork(plan, r, lotId)[0]?.sha ?? null]));
+}
+const short = (c) => `${c.sha.slice(0, 7)} ${c.subject}`;
+/**
+ * Lignes des commits du lot dans ses dépôts voisins, pour `raf commits` et `raf show` : une section par dépôt, du plus
+ * ancien au plus récent comme la liste du projet. Un dépôt introuvable est dit, il ne fait pas échouer la lecture.
+ */
+export function repoSections(plan, base, lot, indent = '') {
+    const { repos, failures } = resolveLotRepos(base, lot);
+    const lines = [];
+    for (const { path: rel } of lot.repos ?? []) {
+        const found = repos.find((r) => r.rel === rel);
+        if (!found) {
+            const failed = failures.find((f) => f.rel === rel);
+            if (failed)
+                lines.push(`${indent}dépôt ${rel} : introuvable (${failed.why})`);
+            continue;
+        }
+        const commits = repoWork(plan, found, lot.id).reverse();
+        if (commits.length === 0)
+            lines.push(`${indent}dépôt ${rel} : aucun commit du lot`);
+        else
+            lines.push(`${indent}dépôt ${rel} :`, ...commits.map((c) => `${indent}  ${short(c)}`));
+    }
+    return lines;
+}

package/package.json

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

package/templates/orchestrate/fix-minors.md

@@ -1,5 +1,6 @@
 Work in `{{chemin}}` on lot `{{lot}}` — "{{titre}}" — of its plan.
 A fresh review found only minor findings: the lot is compliant, and this is the one pass that treats them.
+{{repos}}
 Commits of the lot so far:
 {{commits}}
 

package/templates/orchestrate/fix.md

@@ -1,5 +1,6 @@
 Work in `{{chemin}}` on lot `{{lot}}` — "{{titre}}" — of its plan. A fresh review of the commits
 of this lot found the defects below; fix them, and nothing else.
+{{repos}}
 Commits of the lot so far:
 {{commits}}
 

package/templates/orchestrate/implement.md

@@ -1,6 +1,7 @@
 Work in `{{chemin}}` on lot `{{lot}}` — "{{titre}}" — of its plan
 (`docs/plan/raf.yaml`, or the file named by `plan:` in `cadence.yaml`; read the lot, its notes and sub-tasks, and the project's CLAUDE.md first).
 Goal: {{objectif}}
+{{repos}}
 Rules: test first; commit each sub-part as soon as its tests pass, with explicit paths (never
 `git add -A` or `commit -a`), and a message that cites the lot (`feat({{lot}}): …`); run the project's
 full test suite and build before reporting; do not push, deliver, run `raf done`, `raf ux` or

package/templates/orchestrate/precheck.md

@@ -1,6 +1,7 @@
 Pre-check for lot `{{lot}}` — "{{titre}}" — of the repository `{{chemin}}`, as the read-only pre-check reader.
 Question: is the deliverable of this lot ALREADY in the repository (done by another lot, or by a correction)?
 Goal of the lot: {{objectif}}
+{{repos}}
 Read the lot, its notes and sub-tasks in the plan (`docs/plan/raf.yaml`, or the file named by `plan:` in `cadence.yaml`),
 then look for the deliverable in the code and tests (`git log`, `grep`, reading the files the lot names). Do not
 implement anything and do not run the full test suite: this is a quick look.

package/templates/orchestrate/review-recheck.md

@@ -4,6 +4,7 @@ treated them. Check that the minor findings fixed are fixed, that the fixes brok
 rest of the lot is still sound: read the diff yourself from the commits that cite the lot
 (`raf commits {{lot}}`, or `git log`), run the checks, report real defects only. A new minor finding
 is reported, not a reason to ask for another pass. This is a code review only.
+{{repos}}
 {{checks}}
 {{choix}}
 A proposed sub-task describes an observable bug (a wrong output, a crash, a measured regression); any other minor finding stays a note of this lot, not a sub-task.

package/templates/orchestrate/review-small.md

@@ -2,6 +2,7 @@ Review lot `{{lot}}` — "{{titre}}" — of the repository `{{chemin}}`, followi
 This lot is small: one single pass covers the code review AND the usability review.
 You are given the repository path and the lot id only: read the diff yourself from the commits that
 cite the lot (`raf commits {{lot}}`, or `git log`), run the checks, report real defects only.
+{{repos}}
 {{ux}}
 {{checks}}
 {{choix}}

package/templates/orchestrate/review.md

@@ -1,6 +1,7 @@
 Review lot `{{lot}}` — "{{titre}}" — of the repository `{{chemin}}`, following your agent instructions.
 You are given the repository path and the lot id only: read the diff yourself from the commits that
 cite the lot (`raf commits {{lot}}`, or `git log`), run the checks, report real defects only.
+{{repos}}
 {{checks}}
 {{choix}}
 A proposed sub-task describes an observable bug (a wrong output, a crash, a measured regression); any other minor finding stays a note of this lot, not a sub-task.