@codedology/code-forge 0.7.3 → 0.7.5

package/src/state/block.mjs

@@ -17,9 +17,10 @@ import os from 'node:os';
 import path from 'node:path';
 import { BLOCK_KINDS, blockKind, dispatchLevel } from '../decide/escalation.mjs';
 import { exec } from '../util/exec.mjs';
+import { ownedKinds, pathKind } from './owned-kinds.mjs';
 import { isAncestorArgv, revParseArgv } from '../util/git.mjs';
 import { StateError } from './paths.mjs';
-import { assertOwned, findOverlap, scopeGate } from './registry.mjs';
+import { assertOwned, findOverlap, isExactEntry, ownsFile, scopeGate } from './registry.mjs';
 import { checkWorkerPin, readRun, saveRun, withRunLock, writeSigned } from './run.mjs';
 import { verifyRow, loadKey } from './signer.mjs';
 
@@ -289,13 +290,16 @@ export async function openBlock(opts) {
 
   const block = await mutateRun(runId, null, writeRow, async (record) => {
     if (record.blocks[id]?.status === 'open') throw new StateError('already-open', `block ${id} is already open`);
+    // B57: what each exact owned entry is on disk, under the lock (as `block claim`) — a regular
+    // file owns only itself, here and in every later check
+    const kinds = ownedKinds(record.workspace, owned);
     for (const [otherId, other] of Object.entries(activeBlocks(record))) {
-      const pair = findOverlap(owned, other.owned_files);
+      const pair = findOverlap(owned, other.owned_files, { kindsA: kinds, kindsB: other.owned_kinds });
       if (pair) throw new StateError('overlap', `block ${id} owns ${pair[0]}, which overlaps ${pair[1]} owned by open block ${otherId}`);
     }
     const baseSha = await resolveCommit(opts.base ?? 'HEAD', record.workspace);
     if (baseSha !== stampedBase || record.workspace !== workspace) throw new StateError('base-moved', `the base moved while block ${id} was being opened; run block open again`);
-    const entry = { block: id, base_sha: baseSha, owned_files: [...owned], level: dispatched.level, kind, attempt, opened_at: now.toISOString(), acceptance, lines_forecast: lines, status: 'open', tree_at_open: treeOpen };
+    const entry = { block: id, base_sha: baseSha, owned_files: [...owned], owned_kinds: { ...kinds }, level: dispatched.level, kind, attempt, opened_at: now.toISOString(), acceptance, lines_forecast: lines, status: 'open', tree_at_open: treeOpen };
     record.blocks[id] = entry;
     const floor = dispatched.trigger === 'docs_floor' ? { requested_level: level, trigger: 'docs_floor' } : {};
     return {
@@ -318,7 +322,8 @@ export async function attemptBlock({ runId, id, writeRow }) {
  * `block rebase` — move the base to `head` only when the old base is its ancestor and no commit
  * in between touched a file this block owns (that is a conflict ⇒ stop). Rename detection is OFF
  * (`--no-renames`): a rename lists both its old and its new path, so moving an owned file away
- * is a conflict too. Never silent.
+ * is a conflict too. Never silent. Owned means `ownsFile` (B57: a directory entry owns the files
+ * below it).
  * @param {{runId: string, id: string, head?: string, writeRow: WriteRow}} opts
  * @returns {Promise<{old_base: string, new_base: string}>}
  */
@@ -329,7 +334,7 @@ export async function rebaseBlock({ runId, id, head = 'HEAD', writeRow }) {
     const ancestor = await git(isAncestorArgv(block.base_sha, newBase), cwd, [0, 1]);
     if (ancestor.code !== 0) throw new StateError('base-not-ancestor', `block ${id}: base ${block.base_sha.slice(0, 12)} is not an ancestor of ${head}`);
     const diff = await git(['git', 'diff', '--no-renames', '--name-only', block.base_sha, newBase], cwd);
-    const conflicts = diff.stdout.split('\n').filter((file) => file.length > 0 && findOverlap(block.owned_files, [file]) !== null);
+    const conflicts = diff.stdout.split('\n').filter((file) => file.length > 0 && ownsFile(block.owned_files, file, block.owned_kinds));
     if (conflicts.length > 0) throw new StateError('owned-conflict', `block ${id}: commits since its base changed owned files: ${conflicts.join(', ')}`);
     const moved = { old_base: block.base_sha, new_base: newBase };
     block.base_sha = newBase;
@@ -339,18 +344,25 @@ export async function rebaseBlock({ runId, id, head = 'HEAD', writeRow }) {
 
 /**
  * `block claim` — assign one EXACT path (an orphan, or any unowned path) to `id`; refused for a
- * glob, and when another open block owns it.
+ * glob, and when another open block owns it — or anything it would own: the claimed path becomes an
+ * owned entry, so it is checked with `findOverlap` (B57: an entry owns the paths below it too,
+ * unless it is a regular file now — its kind is recorded in `owned_kinds` as at `block open`).
  * @param {{runId: string, id: string, file: string, writeRow: WriteRow}} opts
  */
 export async function claimPath({ runId, id, file, writeRow }) {
   assertOwned([file]);
-  if (/[*?{]/.test(file)) throw new StateError('bad-owned', `block claim takes one exact path, not a glob (${JSON.stringify(file)})`);
+  if (!isExactEntry(file)) throw new StateError('bad-owned', `block claim takes one exact path, not a glob (${JSON.stringify(file)})`);
   await mutateRun(runId, id, writeRow, (record, block) => {
+    const kinds = { [file]: pathKind(record.workspace, file) };
     for (const [otherId, other] of Object.entries(activeBlocks(record))) {
-      if (otherId !== id && findOverlap([file], other.owned_files)) throw new StateError('overlap', `${file} is owned by open block ${otherId}`);
+      const pair = otherId === id ? null : findOverlap([file], other.owned_files, { kindsA: kinds, kindsB: other.owned_kinds });
+      if (pair) throw new StateError('overlap', `${file} overlaps ${pair[1]} owned by open block ${otherId}`);
     }
-    if (!block.owned_files.includes(file)) block.owned_files.push(file);
-    record.orphans = record.orphans.filter((/** @type {string} */ o) => o !== file);
+    if (!block.owned_files.includes(file)) {
+      block.owned_files.push(file);
+      block.owned_kinds = { ...block.owned_kinds, ...kinds };
+    }
+    record.orphans = record.orphans.filter((/** @type {string} */ o) => !ownsFile([file], o, kinds));
     return { result: undefined, rows: [{ event: 'block.claim', block: id, path: file }] };
   });
 }

package/src/state/owned-kinds.mjs

@@ -0,0 +1,44 @@
+/**
+ * B57: what each EXACT owned entry is on disk when a block is opened or a path claimed — the
+ * answer the registry's ownership rule (`state/registry.mjs`) reads through `owned_kinds`. Only a
+ * regular file (`lstat`, so never a symlink, whatever it points at) is `file`: it owns only itself.
+ * Everything else stays directory-like (fail closed): `dir`, `absent` (not there yet, or a parent
+ * is not a directory), `other` (a symlink, a socket, or a path `lstat` could not read).
+ */
+
+import { lstatSync } from 'node:fs';
+import path from 'node:path';
+import { isExactEntry } from './registry.mjs';
+
+/** @typedef {'file' | 'dir' | 'absent' | 'other'} OwnedKind */
+
+/**
+ * @param {string} root - the directory the entry is relative to (the run's workspace).
+ * @param {string} entry - a repo-relative POSIX path (already through `assertOwned`).
+ * @returns {OwnedKind}
+ */
+export function pathKind(root, entry) {
+  let st;
+  try {
+    st = lstatSync(path.join(root, ...entry.split('/')));
+  } catch (err) {
+    const code = /** @type {any} */ (err)?.code;
+    return code === 'ENOENT' || code === 'ENOTDIR' ? 'absent' : 'other';
+  }
+  if (st.isFile()) return 'file';
+  if (st.isDirectory()) return 'dir';
+  return 'other';
+}
+
+/**
+ * The kind of every exact entry of `owned` (`isExactEntry` — a glob has no kind), keyed by the
+ * entry as written.
+ * @param {string} root @param {ReadonlyArray<string>} owned
+ * @returns {Record<string, OwnedKind>}
+ */
+export function ownedKinds(root, owned) {
+  /** @type {Record<string, OwnedKind>} */
+  const kinds = Object.create(null); // an entry named `__proto__` is a key like any other
+  for (const entry of owned) if (isExactEntry(entry)) kinds[entry] = pathKind(root, entry);
+  return kinds;
+}

package/src/state/registry.mjs

@@ -18,11 +18,29 @@
  * `test/fixtures/repos/node/**` are disjoint, `src/**` and `src/cli/*.mjs` overlap, and so do
  * `src/*.mjs` and `src/cli/*.mjs` (they cannot share a path, but overlap is not ruled out by
  * the prefix rule — the owner resolves it by naming exact paths).
+ *
+ * B57 — ONE ownership rule, here, for every caller (block open/claim/rebase, the scope gate, the
+ * worker's file set and budget, proof, plan check, the close gate's `ownsPath`): an entry with no
+ * glob character (`*`, `?`, `{`) owns that exact path AND every path below it, as a directory
+ * would (`src/feature` owns `src/feature/a.swift`, never `src/featureX/a.swift`); a glob entry
+ * matches as above and nothing more — a brace entry (`src/{a,b}`) is a glob, so each alternative
+ * owns exactly itself, nothing below it. This module is pure and cannot tell a file from a
+ * directory, so the caller passes what it saw: `kinds` (a block's `owned_kinds`, recorded at
+ * `block open` and `block claim` by `state/owned-kinds.mjs`) maps an exact entry to `file` when it
+ * was a regular file — then it owns only itself. Any other kind, or no kind (not there yet, an
+ * older block, a plan), stays directory-like: fail closed. So `findOverlap` reports a parent/child
+ * pair of directory-like entries (either way round), and a directory-like entry against a glob
+ * that matches the entry itself or ANY path below it (decided exactly, `globBelow`: `src/feature`
+ * vs `src/**` and vs `src/feature/*.swift` overlap, vs `src/*.mjs` and `src/featureX/*` do not);
+ * a `file` entry against a glob overlaps only when the glob matches it (`src/README` vs
+ * `src/**\/*.mjs` does not).
  */
 
 import { StateError } from './paths.mjs';
 
 const GLOB_CHARS = /[*?]/;
+/** What makes an owned ENTRY a glob (B57: the one definition): `*`, `?`, or a `{a,b}` group. */
+const GLOB_ENTRY_CHARS = /[*?{]/;
 /** Glob syntax this matcher does NOT implement — refused inside a glob entry only. */
 const UNSUPPORTED_GLOB_CHARS = /[[\]()!+@]/;
 
@@ -99,7 +117,7 @@ export function assertOwned(owned) {
     };
     if (typeof entry !== 'string' || entry.length === 0) refuse('must be a non-empty string');
     if (entry.includes('\\')) refuse('backslashes are not allowed (POSIX paths only)');
-    const isGlob = /[*?{]/.test(entry);
+    const isGlob = !isExactEntry(entry);
     if (isGlob && UNSUPPORTED_GLOB_CHARS.test(entry)) {
       refuse('a glob may not contain [ ] ( ) ! + @ — character classes and extglobs are not supported; name the files exactly or use only *, ?, ** and {a,b}');
     }
@@ -123,43 +141,124 @@ function staticSegments(p) {
 const segmentPrefix = (a, b) => a.length <= b.length && a.every((s, i) => s === b[i]);
 
 /**
- * @param {string} a @param {string} b - brace-free patterns
+ * What a caller saw on disk for each exact owned entry (B57, the module doc); only `file` changes
+ * the rule. Keys are the entries' original spellings.
+ * @typedef {Readonly<Record<string, string>> | null | undefined} OwnedKinds
+ */
+
+/**
+ * B57: is owned `entry` an EXACT path — no `*`, `?` or `{` (`[ ] ( ) ! + @ }` are literal there)?
+ * The one definition `assertOwned`, `block claim`, the ownership rule, proof export and
+ * `state/owned-kinds.mjs` share.
+ * @param {string} entry @returns {boolean}
+ */
+export function isExactEntry(entry) {
+  return !GLOB_ENTRY_CHARS.test(entry);
+}
+
+/**
+ * B57: an exact entry that is not a recorded regular file — it owns its path and everything below
+ * it (see the module doc). `kinds` is keyed by the entry as written.
+ * @param {string} entry @param {OwnedKinds} kinds @returns {boolean}
+ */
+const isTreeEntry = (entry, kinds) => isExactEntry(entry) && !(kinds != null && Object.hasOwn(kinds, entry) && kinds[entry] === 'file');
+
+/**
+ * B57: an exact entry's path for matching — trailing slashes dropped (`assertOwned` refuses them in
+ * the run record; the close gate's callers may still pass one), the same in both functions.
+ * @param {string} entry @returns {string}
+ */
+const exactPath = (entry) => entry.replace(/\/+$/, '');
+
+/** @param {string} root @param {string} file @returns {boolean} `file` is `root` or a path below it. */
+const coversPath = (root, file) => file === root || file.startsWith(`${root}/`);
+
+/**
+ * B57: can brace-free glob `pattern` match some path strictly below directory `dir` (one or more
+ * segments after it)? Decided exactly: `dir`'s segments must match a prefix of the pattern, and
+ * any pattern left over (or a `**` reached on the way) can always be met by some name below.
+ * @param {string} dir @param {string} pattern
+ * @returns {boolean}
+ */
+function globBelow(dir, pattern) {
+  const f = dir.split('/');
+  const p = pattern.split('/');
+  for (let i = 0; ; i += 1) {
+    if (i < p.length && p[i] === '**') return true;
+    if (i === f.length) return i < p.length;
+    if (i === p.length || !segmentRegExp(p[i]).test(f[i])) return false;
+  }
+}
+
+/**
+ * One brace alternative of an owned entry: `tree` when the entry is directory-like (it owns the
+ * paths below it too). An exact entry is one alternative, its {@link exactPath}; an empty one
+ * (`/`) has none.
+ * @typedef {{p: string, tree: boolean}} Alternative
+ * @param {string} entry @param {OwnedKinds} kinds @returns {Alternative[]}
+ */
+function alternatives(entry, kinds) {
+  if (!isExactEntry(entry)) return expandBraces(entry).map((p) => ({ p, tree: false }));
+  const p = exactPath(entry);
+  return p.length === 0 ? [] : [{ p, tree: isTreeEntry(entry, kinds) }];
+}
+
+/**
+ * @param {Alternative} a @param {Alternative} b
  * @returns {boolean}
  */
 function patternsOverlap(a, b) {
-  const aGlob = GLOB_CHARS.test(a);
-  const bGlob = GLOB_CHARS.test(b);
-  if (!aGlob && !bGlob) return a === b;
-  if (!aGlob) return globMatch(a, b);
-  if (!bGlob) return globMatch(b, a);
-  const sa = staticSegments(a);
-  const sb = staticSegments(b);
+  if (b.tree && !a.tree) return patternsOverlap(b, a);
+  if (a.tree) {
+    if (b.tree) return coversPath(a.p, b.p) || coversPath(b.p, a.p);
+    if (!GLOB_CHARS.test(b.p)) return coversPath(a.p, b.p);
+    return globMatch(a.p, b.p) || globBelow(a.p, b.p);
+  }
+  const aGlob = GLOB_CHARS.test(a.p);
+  const bGlob = GLOB_CHARS.test(b.p);
+  if (!aGlob && !bGlob) return a.p === b.p;
+  if (!aGlob) return globMatch(a.p, b.p);
+  if (!bGlob) return globMatch(b.p, a.p);
+  const sa = staticSegments(a.p);
+  const sb = staticSegments(b.p);
   return segmentPrefix(sa, sb) || segmentPrefix(sb, sa);
 }
 
 /**
+ * Could two owned lists ever own one path? An exact entry is directory-like unless its kind says
+ * `file` (B57, the module doc), so `src/feature` and `src/feature/x.swift` overlap either way round.
  * @param {ReadonlyArray<string>} ownedA @param {ReadonlyArray<string>} ownedB
+ * @param {{kindsA?: OwnedKinds, kindsB?: OwnedKinds}} [kinds] - each list's `owned_kinds`.
  * @returns {[string, string] | null} the first overlapping pair (original spellings), or null.
  */
-export function findOverlap(ownedA, ownedB) {
+export function findOverlap(ownedA, ownedB, { kindsA, kindsB } = {}) {
   for (const a of ownedA) {
     for (const b of ownedB) {
-      if (expandBraces(a).some((x) => expandBraces(b).some((y) => patternsOverlap(x, y)))) return [a, b];
+      if (alternatives(a, kindsA).some((x) => alternatives(b, kindsB).some((y) => patternsOverlap(x, y)))) return [a, b];
     }
   }
   return null;
 }
 
 /**
- * @param {ReadonlyArray<string>} owned @param {string} file
+ * Does `owned` own repo-relative `file`? A directory-like exact entry owns its path and every path
+ * below it, a `file` one (per `kinds`) only itself (B57); a glob entry owns what it matches. A
+ * non-string or empty entry owns nothing; an exact entry is matched as its {@link exactPath}, as
+ * in `findOverlap`.
+ * @param {ReadonlyArray<unknown>} owned @param {string} file @param {OwnedKinds} [kinds] - the block's `owned_kinds`.
  * @returns {boolean}
  */
-export function ownsFile(owned, file) {
-  return owned.some((entry) => expandBraces(entry).some((p) => p === file || (GLOB_CHARS.test(p) && globMatch(file, p))));
+export function ownsFile(owned, file, kinds) {
+  return owned.some((entry) => {
+    if (typeof entry !== 'string' || entry.length === 0) return false;
+    if (!isExactEntry(entry)) return expandBraces(entry).some((p) => p === file || (GLOB_CHARS.test(p) && globMatch(file, p)));
+    const root = exactPath(entry);
+    return root.length > 0 && (isTreeEntry(entry, kinds) ? coversPath(root, file) : root === file);
+  });
 }
 
 /**
- * @typedef {{owned_files: string[], status?: string}} RegistryBlock
+ * @typedef {{owned_files: string[], owned_kinds?: Record<string, string>, status?: string}} RegistryBlock
  * @param {Record<string, RegistryBlock>} blocks - the ACTIVE blocks only (status `open`)
  * @param {ReadonlyArray<string>} files - the shared tree's changed + untracked files
  * @returns {{scopes: Record<string, string[]>, orphans: string[]}}
@@ -169,7 +268,7 @@ export function computeScopes(blocks, files) {
   const scopes = Object.fromEntries(Object.keys(blocks).map((id) => [id, []]));
   const orphans = [];
   for (const file of [...new Set(files)].sort()) {
-    const owners = Object.keys(blocks).filter((id) => ownsFile(blocks[id].owned_files, file));
+    const owners = Object.keys(blocks).filter((id) => ownsFile(blocks[id].owned_files, file, blocks[id].owned_kinds));
     if (owners.length === 0) orphans.push(file);
     for (const id of owners) scopes[id].push(file);
   }

package/src/worker/engine.mjs

@@ -34,6 +34,9 @@
  * this run for this file and content hash whose MAC verifies with the run key), so a packet's
  * second `schema` miss — this round's first try after the earlier ticket's — is tried once on
  * `review.second_levels.<level>` when one is configured.
+ * B56: every round gets ONE memoised reader of the block's OTHER changed files' diffs
+ * (`blockPeerDiffs`: listed and read at most once per ticket) so the review can name code moved
+ * between them in a `## moved code` packet section (round 1, rechecks and patch check alike).
  * The review NEVER approves an empty or failed session: that is `unavailable` (§4.2 stub guard).
  * A throw inside the round is `unavailable` too, with the state saved as `next: retry` (see
  * `fixLoopRound`): the next ticket re-runs that round, never a fresh round 1.
@@ -46,6 +49,7 @@ import { askJev } from '../decide/jev-client.mjs';
 import { planAndRecord, tierOf } from '../review/budget.mjs';
 import { budgetFor } from '../review/packet.mjs';
 import { reviewFile, rulesRisk } from '../review/engine.mjs';
+import { peerDiffReader } from '../review/moved.mjs';
 import { computeFileSet, ownsFile } from '../gates/scope.mjs';
 import { extraRoundsFor, newFileState, reopenForExtraRound, runRound } from '../review/fixloop.mjs';
 import { readRun } from '../state/run.mjs';
@@ -103,16 +107,17 @@ import { assertTicketId } from './ticket.mjs';
  * block entry without a base `block-base-missing` — a guessed base could let a change escape review.
  * @param {string} runId @param {string} block
  * The block's kind (B34) is the recorded `kind` when `block open` stored one, else `blockKind`
- * of its owned files.
+ * of its owned files. `ownedKinds` is the recorded `owned_kinds` (B57: which exact entries were
+ * regular files at `block open`/`claim`), `{}` when there is none (every exact entry directory-like).
  *   With no run record the kind is null: `reviewTicket` takes the ticket file's kind.
- * @returns {Promise<{base: string | null, level: string, owned: string[], acceptance?: unknown, kind: string | null}>}
+ * @returns {Promise<{base: string | null, level: string, owned: string[], ownedKinds: Record<string, string>, acceptance?: unknown, kind: string | null}>}
  */
 export async function blockEntryFor(runId, block) {
   let record;
   try {
     record = await readRun(runId);
   } catch (err) {
-    if (/** @type {any} */ (err)?.code === 'no-run') return { base: null, level: 'L2', owned: [], acceptance: undefined, kind: null };
+    if (/** @type {any} */ (err)?.code === 'no-run') return { base: null, level: 'L2', owned: [], ownedKinds: {}, acceptance: undefined, kind: null };
     throw new Error('run-record-unreadable');
   }
   if (!record || typeof record !== 'object' || !record.blocks || typeof record.blocks !== 'object') throw new Error('run-record-unreadable');
@@ -121,7 +126,9 @@ export async function blockEntryFor(runId, block) {
   const sha = entry?.base_sha;
   if (typeof sha !== 'string' || sha.length === 0) throw new Error('block-base-missing');
   const owned = Array.isArray(entry.owned_files) ? entry.owned_files.filter((f) => typeof f === 'string') : [];
-  return { base: sha, level: typeof entry.level === 'string' && /^L[0-3]$/.test(entry.level) ? entry.level : 'L2', owned, acceptance: entry.acceptance, kind: blockKind({ owned, declared: entry.kind }) };
+  const kinds = entry.owned_kinds;
+  const ownedKinds = kinds && typeof kinds === 'object' && !Array.isArray(kinds) ? kinds : {};
+  return { base: sha, level: typeof entry.level === 'string' && /^L[0-3]$/.test(entry.level) ? entry.level : 'L2', owned, ownedKinds, acceptance: entry.acceptance, kind: blockKind({ owned, declared: entry.kind }) };
 }
 
 /** The acceptance line written when the block's clauses cannot be read. */
@@ -206,19 +213,60 @@ export async function reviewTicket(ticket, ctx) {
     return { status: 'unavailable', reason: err instanceof Error ? err.message : 'run-record-unreadable', approved: false, engine: 'adaptive', sessions: [] };
   }
   if (entry.kind === null) entry = { ...entry, kind: blockKind({ owned: [ticket.file] }) };
+  const peerDiffs = blockPeerDiffs(ctx.repoRoot, { base: entry.base, owned: entry.owned, ownedKinds: entry.ownedKinds, file: ticket.file });
   try {
     if (!ctx.key) {
       return await reviewFile(
-        { repoRoot: ctx.repoRoot, file: ticket.file, base: entry.base, cfg: ctx.cfg, kind: entry.kind, workDir, factsExcerpt: acceptanceExcerpt(entry.acceptance, ctx.cfg) },
+        { repoRoot: ctx.repoRoot, file: ticket.file, base: entry.base, cfg: ctx.cfg, kind: entry.kind, workDir, factsExcerpt: acceptanceExcerpt(entry.acceptance, ctx.cfg), peerDiffs },
         { spawn: ctx.spawn, ...(ctx.writeRow ? { writeRow: ctx.writeRow } : {}) },
       );
     }
-    return await fixLoopRound(ticket, ctx, { base: entry.base, level: entry.level, owned: entry.owned, blockKindOf: entry.kind, key: ctx.key, workDir, factsExcerpt: acceptanceExcerpt(entry.acceptance, ctx.cfg) });
+    return await fixLoopRound(ticket, ctx, { base: entry.base, level: entry.level, owned: entry.owned, ownedKinds: entry.ownedKinds, blockKindOf: entry.kind, key: ctx.key, workDir, factsExcerpt: acceptanceExcerpt(entry.acceptance, ctx.cfg), peerDiffs });
   } finally {
     rmSync(workDir, { recursive: true, force: true });
   }
 }
 
+/**
+ * B56: the block's OTHER changed files — the §4.1 file set since the block base (tracked changes ∪
+ * untracked), filtered to the block's owned files (`ownsFile`, as the budget row does), minus the
+ * ticket's file. The review names code moved between them (`## moved code`). No base, no owned
+ * list, or a git failure ⇒ [] (no hint; the review itself goes on unchanged).
+ * @param {string} repoRoot @param {{base: string | null, owned: string[], ownedKinds?: Record<string, string>, file: string}} opts
+ * @returns {Promise<string[]>}
+ */
+export async function blockPeers(repoRoot, { base, owned, ownedKinds, file }) {
+  if (base === null || !Array.isArray(owned) || owned.length === 0) return [];
+  try {
+    return (await computeFileSet({ cwd: repoRoot, base })).all.filter((f) => f !== file && ownsFile(owned, f, ownedKinds));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * B56: ONE memoised reader per ticket of the block's other changed files' diffs: the file set is
+ * listed and the diffs read (`peerDiffReader`) at most once, however many packets ask — lazily, so
+ * a round with no packet (a stopped file) runs no git call. Any throw or rejection on the way ⇒
+ * no peer diffs (no hint), memoised like a success.
+ * @param {string} repoRoot @param {{base: string | null, owned: string[], ownedKinds?: Record<string, string>, file: string}} opts
+ * @returns {() => Promise<import('../review/moved.mjs').PeerDiff[]>}
+ */
+export function blockPeerDiffs(repoRoot, { base, owned, ownedKinds, file }) {
+  /** @type {Promise<import('../review/moved.mjs').PeerDiff[]> | null} */
+  let once = null;
+  return () => {
+    once ??= (async () => {
+      try {
+        return await peerDiffReader({ repoRoot, base, file, peers: await blockPeers(repoRoot, { base, owned, ownedKinds, file }) })();
+      } catch {
+        return [];
+      }
+    })();
+    return once;
+  };
+}
+
 /**
  * The key of a block's lock (B42): the block's budget row and its L3 rung are taken under it.
  * It carries the run, so two runs in one process never share a lock.
@@ -281,10 +329,10 @@ export function mayTakeRung(state, kind, cfg, rungUsed) {
  * first full round, or any round once the rung is gone) runs outside the block lock, in parallel
  * with the block's other files.
  * @param {import('./queue.mjs').Ticket} ticket @param {ReviewContext} ctx
- * @param {{base: string | null, level: string, owned: string[], blockKindOf: string, key: Buffer, workDir: string, factsExcerpt: string}} opts
+ * @param {{base: string | null, level: string, owned: string[], ownedKinds?: Record<string, string>, blockKindOf: string, key: Buffer, workDir: string, factsExcerpt: string, peerDiffs?: () => Promise<import('../review/moved.mjs').PeerDiff[]>}} opts
  * @returns {Promise<ReviewOutcome>}
  */
-async function fixLoopRound(ticket, ctx, { base, level, owned, blockKindOf, key, workDir, factsExcerpt }) {
+async function fixLoopRound(ticket, ctx, { base, level, owned, ownedKinds, blockKindOf, key, workDir, factsExcerpt, peerDiffs }) {
   if (!ctx.readRows || !ctx.writeRow) return { status: 'unavailable', reason: 'no-ledger', approved: false, engine: 'adaptive', sessions: [] };
   const readRows = ctx.readRows;
   /** @type {{outcome: ReviewOutcome} | {round: () => Promise<ReviewOutcome>}} */
@@ -298,7 +346,7 @@ async function fixLoopRound(ticket, ctx, { base, level, owned, blockKindOf, key,
     // Check-then-write under the block lock: no other ticket of this block reads the rows between
     // this check and the budget row's write, so the row is written once per block.
     if (!rows.some((r) => r?.event === 'review.budget' && r.block === ticket.block)) {
-      await recordBlockBudget(ticket, ctx, { base, owned });
+      await recordBlockBudget(ticket, ctx, { base, owned, ownedKinds });
     }
     const where = { runRootDir: ctx.runRootDir, runId: ctx.runId, block: ticket.block, file: ticket.file, key, rows };
     const loaded = loadState(where);
@@ -324,7 +372,7 @@ async function fixLoopRound(ticket, ctx, { base, level, owned, blockKindOf, key,
       state.l3_rung_used = true; // the orchestrator ran the block's one L3 patch before this ticket
     }
     const fixed = state;
-    const round = () => playRound(ticket, ctx, { state: fixed, kind, where, seq: loaded.seq, base, blockKindOf, workDir, factsExcerpt, extraRounds });
+    const round = () => playRound(ticket, ctx, { state: fixed, kind, where, seq: loaded.seq, base, blockKindOf, workDir, factsExcerpt, extraRounds, peerDiffs });
     // a round that could take the rung keeps the block lock until its state is saved
     if (mayTakeRung(fixed, kind, ctx.cfg, rungUsed)) return { outcome: await round() };
     return { round };
@@ -335,10 +383,10 @@ async function fixLoopRound(ticket, ctx, { base, level, owned, blockKindOf, key,
 /**
  * Run the prepared round and save the file's state: the ticket's outcome.
  * @param {import('./queue.mjs').Ticket} ticket @param {ReviewContext} ctx
- * @param {{state: import('../review/fixloop.mjs').FileState, kind: 'full' | 'recheck' | 'patch_check', where: import('./review-state.mjs').Where, seq: number, base: string | null, blockKindOf: string, workDir: string, factsExcerpt: string, extraRounds?: number}} opts
+ * @param {{state: import('../review/fixloop.mjs').FileState, kind: 'full' | 'recheck' | 'patch_check', where: import('./review-state.mjs').Where, seq: number, base: string | null, blockKindOf: string, workDir: string, factsExcerpt: string, extraRounds?: number, peerDiffs?: () => Promise<import('../review/moved.mjs').PeerDiff[]>}} opts
  * @returns {Promise<ReviewOutcome>}
  */
-async function playRound(ticket, ctx, { state, kind, where, seq, base, blockKindOf, workDir, factsExcerpt, extraRounds = 0 }) {
+async function playRound(ticket, ctx, { state, kind, where, seq, base, blockKindOf, workDir, factsExcerpt, extraRounds = 0, peerDiffs }) {
   /** @type {Record<string, any> | null} */
   let engineOutcome = null;
   let approvalWritten = false;
@@ -388,10 +436,11 @@ async function playRound(ticket, ctx, { state, kind, where, seq, base, blockKind
         writeRow,
         factsExcerpt,
         extraRounds,
+        ...(peerDiffs ? { peerDiffs } : {}),
         ...(jev ? { jev } : {}),
         ...(schemaHistory ? { schemaHistory } : {}),
         review: async () => {
-          engineOutcome = await reviewFile({ repoRoot: ctx.repoRoot, file: ticket.file, base, cfg: ctx.cfg, kind: blockKindOf, workDir, factsExcerpt }, { spawn: ctx.spawn, writeRow, ...(schemaHistory ? { schemaHistory } : {}) });
+          engineOutcome = await reviewFile({ repoRoot: ctx.repoRoot, file: ticket.file, base, cfg: ctx.cfg, kind: blockKindOf, workDir, factsExcerpt, ...(peerDiffs ? { peerDiffs } : {}) }, { spawn: ctx.spawn, writeRow, ...(schemaHistory ? { schemaHistory } : {}) });
           return engineOutcome;
         },
         spawn: async (opts) => {
@@ -443,15 +492,15 @@ async function playRound(ticket, ctx, { state, kind, where, seq, base, blockKind
  * not run yet), written as ONE `review.budget` row (+ `review.over_budget` when over). Best effort:
  * a git or ledger failure is swallowed, the review goes on.
  * @param {import('./queue.mjs').Ticket} ticket @param {ReviewContext} ctx
- * @param {{base: string | null, owned: string[]}} opts
+ * @param {{base: string | null, owned: string[], ownedKinds?: Record<string, string>}} opts
  */
-async function recordBlockBudget(ticket, ctx, { base, owned }) {
+async function recordBlockBudget(ticket, ctx, { base, owned, ownedKinds }) {
   try {
     /** @type {string[]} */
     let changed = [];
     if (base !== null && owned.length > 0) {
       try {
-        changed = (await computeFileSet({ cwd: ctx.repoRoot, base })).all.filter((f) => ownsFile(owned, f));
+        changed = (await computeFileSet({ cwd: ctx.repoRoot, base })).all.filter((f) => ownsFile(owned, f, ownedKinds));
       } catch {
         // no row on a git failure: a ticket-only forecast would be permanent (the row is written
         // once per block); the block's next keyed ticket retries