@sylad/cadence 0.15.0 → 0.17.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.17.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.17.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.17.0**: `cadence-hud` shows an `N cmd` segment next to the agents, the background commands of the session (Bash run in the background and Monitor, subagents' included), tracked from the tool results and ended by the task's notification or `TaskStop`. **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.
@@ -1039,14 +1100,14 @@ repository with `cadence skills install` (to `.claude/skills/cadence-*` and
 A band above the Claude Code prompt (terminal and desktop app), refreshed every 5 s:
 
 ```
-ctx ▰▰▰▰▱▱▱▱▱▱  42 % 84k/200k  │  5h  23 % ↻ 2 h 10  │  7j  61 % ↻ 6 j 15 h  │  $1.23  │  fable 410k sonnet 85k  │  ⚙ 2 agents
+ctx ▰▰▰▰▱▱▱▱▱▱  42 % 84k/200k  │  5h  23 % ↻ 2 h 10  │  7j  61 % ↻ 6 j 15 h  │  $1.23  │  fable 410k sonnet 85k  │  ⚙ 2 agents  │  2 cmd
 ⟳ cadence · 2026-10-07-2131 en cours  │  budget ▱▱▱▱▱▱▱▱▱▱   1 % 14k/2M  │  1 session/2
   L112  implémente  implement@sonnet 34 s         global-setup coupe le cache de compilation de Node...
 ```
 
 Context of the session (green / orange / red at 50 and 75 %), the 5-hour and 7-day quota
 windows with the time to their reset, the cost of the session and its split per model, the
-subagents of this session, and every live `cadence orchestrate` wave: budget, sessions, one
+subagents of this session, the background commands in progress (`2 cmd`: Bash run in the background and Monitor, subagents' included, as the app's "background commands" card counts them), and every live `cadence orchestrate` wave: budget, sessions, one
 aligned line per active lot (status, step, model, elapsed, start of the title), the lots still
 waiting. When no wave is running, the last finished one stays on a grey line until the next
 starts. Waves are read from disk (`~/.cadence/orchestrate/waves/`, then `.cadence/runs/`); no

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.17.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.