@codedology/code-forge 0.7.3 → 0.7.4

package/CHANGELOG.md

@@ -6,6 +6,17 @@ waits on a second real consumer (plan §10.4, Q17).
 
 ## [Unreleased]
 
+## [0.7.4] — 2026-10-08
+
+### Added
+
+- Review: code moved between two changed files of the same block is named in a ## moved code packet section
+  (deterministic line matching against the block's other changed owned files, same base: >= 3 significant lines or >=
+  120 significant characters; at most 12 ranges; a Markdown section packet lists only the moves in that section) in
+  round 1, rechecks, patch checks and the judge packet, so the source file's reviewer no longer reports the removal as a
+  deleted feature; every hunk and the reviewed_hunks check are unchanged, and the section counts toward the packet
+  budget (issue #2).
+
 ## [0.7.3] — 2026-10-08
 
 ### Added

package/README.md

@@ -12,6 +12,13 @@ for cross-model, parallel, evidence-gated feature delivery — on Claude Code, C
 
 Next release:
 
+- **Code moved between files is no longer read as deleted.** When a block moves code from one
+  file to another, each file's review packet now says where the lines went (or came from), so the
+  reviewer of the old file stops reporting the removal as a lost feature, also on rechecks. Every
+  hunk is still reviewed.
+
+In 0.7.3:
+
 - **A model that keeps failing the answer format gets a stand-in.** When a reviewer's answer
   fails the schema twice on the same packet and you set `review.second_levels` for that level, the
   worker retries that packet once with the second model, and the ledger records it. Each failed

package/docs/reference/blocks.json

@@ -4,7 +4,7 @@
     "plans/code-forge-plan-v1.3.md §10.4",
     "plans/NIGHT-LOG.md"
   ],
-  "block_count": 58,
+  "block_count": 59,
   "baseline_ids": ["B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8"],
   "baseline_note": "Wave 0-1 blocks, landed before v1.3; depends_on may name them, but they have no entry under blocks.",
   "blocks": {
@@ -794,6 +794,22 @@
         "B54"
       ],
       "note": "root-added 2026-10-08; GitHub issue #2 note of 2026-10-06; also amends src/review/{engine,fixloop,validate-review}.mjs, src/worker/engine.mjs, src/session/spawn.mjs (stderr tail moved to util), src/autopilot/binnacle.mjs, test fakes, docs/how-it-works.md, skill/references/review.md"
+    },
+    "B56": {
+      "title": "Moved-code hint (issue #2): code moved between changed files of the same block is detected by deterministic line matching (>= 3 significant lines or >= 120 significant characters; peers in the base diffed against it, deleted peers included) and named in a ## moved code packet section on both files, in round 1, rechecks, patch checks, the judge packet and per Markdown section; extra text only (every hunk and reviewed_hunks unchanged); counted in the packet budget with one measure; unsafe peer names never read or printed; peer diffs read once per ticket with a 2 MiB per-peer cap",
+      "wave": 12,
+      "level": "L2",
+      "status": "landed",
+      "owned": [
+        "src/review/moved.mjs",
+        "test/review/moved.test.mjs",
+        "test/review/moved-wiring.test.mjs",
+        "test/worker/moved-peers-guard.test.mjs"
+      ],
+      "depends_on": [
+        "B55"
+      ],
+      "note": "root-added 2026-10-08; GitHub issue #2 note of 2026-10-06 (stale critical from a cross-file move); also amends src/review/{packet,engine,fixloop,sections}.mjs, src/worker/engine.mjs, docs/how-it-works.md, skill/references/review.md"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codedology/code-forge",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "Plan/harden/code/review orchestration CLI and Agent Skill for cross-model, parallel, evidence-gated feature delivery.",
   "repository": {
     "type": "git",

package/skill/references/review.md

@@ -15,7 +15,7 @@ The topology is decided in one place (`planSessions`). Consensus (§6) runs only
 
 ## §3 Isolation and the packet
 
-Every reviewer, recheck, judge and S2 session runs with cwd = a fresh empty temp dir under the run's temp root and the packet **on stdin** — a no-tools session never opens a path and the packet never enters argv. Packet order is fixed so provider prompt caching applies: lens, project rules digest (≤ 60 lines), facts-sheet excerpt for the symbols in the diff, context, diff. Context: a file at or under `review.context.whole_file_max_lines` travels whole; above it each hunk carries ± `review.context.hunk_context_lines` lines; over `review.budgets.full_in` the context shrinks to ± `review.context.min_context_lines`, then the digest is trimmed, never the diff; a diff alone over budget ⇒ `split_required`, with `tokens_in` and `budget` in the result, its ledger `review.result` row and the `review-file --wait` answer (`stop: split_required`) — except a Markdown file (`.md`, `.markdown`), which is reviewed **section by section**: the diff is cut at its headings (`#`..`######`, not inside fenced code), consecutive sections share a packet while it fits, every section packet runs the file's whole plan with its own stub guard, the file is approved only when every section is, and findings are merged with ids `S<section>.<id>`; a recheck over budget is split the same way, each open finding listed in its own section's packet. A section that alone is over budget keeps the file `split_required` (with that `section`), and so does a deleted Markdown file or one with no heading (fail-safe: one section); nothing is ever truncated. The closed-book rule is in every lens: judge only what is in the packet; a file you cannot see goes in `needs_file`, and the worker attaches it (read-only, trimmed) for **one** more round.
+Every reviewer, recheck, judge and S2 session runs with cwd = a fresh empty temp dir under the run's temp root and the packet **on stdin** — a no-tools session never opens a path and the packet never enters argv. Packet order is fixed so provider prompt caching applies: lens, project rules digest (≤ 60 lines), facts-sheet excerpt for the symbols in the diff, context, diff. Context: a file at or under `review.context.whole_file_max_lines` travels whole; above it each hunk carries ± `review.context.hunk_context_lines` lines; over `review.budgets.full_in` the context shrinks to ± `review.context.min_context_lines`, then the digest is trimmed, never the diff; a diff alone over budget ⇒ `split_required`, with `tokens_in` and `budget` in the result, its ledger `review.result` row and the `review-file --wait` answer (`stop: split_required`) — except a Markdown file (`.md`, `.markdown`), which is reviewed **section by section**: the diff is cut at its headings (`#`..`######`, not inside fenced code), consecutive sections share a packet while it fits, every section packet runs the file's whole plan with its own stub guard, the file is approved only when every section is, and findings are merged with ids `S<section>.<id>`; a recheck over budget is split the same way, each open finding listed in its own section's packet. A section that alone is over budget keeps the file `split_required` (with that `section`), and so does a deleted Markdown file or one with no heading (fail-safe: one section); nothing is ever truncated. Moved code (B56): code moved between two changed files of the same block is named in a `## moved code` section before the diff (`- base lines a-b removed here were added in <file> lines c-d in this block.` / `- lines c-d were moved here from <file> (its base lines a-b) in this block.`), in round 1, rechecks, patch checks and the judge's packet. Detection is deterministic line matching against the block's other changed owned files diffed against the same base: lines trimmed with whitespace collapsed, lines with fewer than 4 letters or digits ignored, a moved stretch needs ≥ 3 such lines or ≥ 120 such characters; at most 12 ranges are listed; a Markdown section packet lists only the moves under its own headings (none ⇒ no section); the peers are listed and read once per review (one `git ls-tree <base>`, one `git diff <base>` over the peers that exist in the base — a peer deleted in the block, staged or not, is all removed lines — one `git check-ignore` and one `git diff --no-index` per new peer; `a/`/`b/` prefixes forced, `core.quotePath=false`; a peer name with a control, bidi or separator character, a quote or a backslash is skipped; a peer whose diff is over 2 MiB is skipped, never buffered past that); a removed block cut right above a heading belongs to the section holding its removed hunk; a move inside one file is not detected. It is extra text counted in the packet budget: every hunk stays, `reviewed_hunks` is unchanged, and a removal listed there is not a defect by itself — only stale references or imports are. The closed-book rule is in every lens: judge only what is in the packet; a file you cannot see goes in `needs_file`, and the worker attaches it (read-only, trimmed) for **one** more round.
 
 ## §4 The stub guard — what counts as a review (R11)
 

package/skill/scripts/forge

@@ -10,7 +10,7 @@
 #      copied install with no package next to it); `test/skill/shim.test.mjs` asserts the pin
 #      equals package.json's version.
 # The shim holds no logic of its own: every verb, flag and message is the CLI's.
-PINNED_VERSION="0.7.3"
+PINNED_VERSION="0.7.4"
 set -eu
 
 self="$0"

package/src/review/engine.mjs

@@ -33,7 +33,13 @@
  *     reviewed (the file is then `unavailable`). The file is approved only when EVERY section is;
  *     the findings of all sections are merged with ids `S<section>.<id>`, every session summary
  *     names its `section`, and `sections` lists them. A section that alone is still over the
- *     budget keeps the file `split_required` (plus `section`: its heading) — never truncated.
+ *     budget keeps the file `split_required` (plus `section`: its heading) — never truncated;
+ *  8. code moved between this file and another changed file of the block (`input.peers`, both
+ *     diffed against the block base) is named in a `## moved code` section of every packet —
+ *     reviewers and judge; a Markdown section packet lists only the moves in that section
+ *     (`moved.mjs`, B56). The peers' diffs are read once per review (`input.peerDiffs`, or a
+ *     reader built from `input.peers`). It is extra text: every hunk still goes to the reviewer,
+ *     and it counts toward the budget in the same measure.
  * Approval (until B12b's triage lands) = the final answer (the judge's in dual/consensus mode, else
  * the single reviewer's) passed the guard, says `passed: true`, and carries no `critical` or
  * `warning` finding.
@@ -47,6 +53,7 @@ import { blockKind, isDocsKind } from '../decide/escalation.mjs';
 import { fallbackRisk } from '../decide/fallback-rules.mjs';
 import { tierFor } from '../proof/tiers.mjs';
 import { assembleJudgePacket, assemblePacket, attachFiles, budgetFor, diffOnlyTokens, readFileDiff } from './packet.mjs';
+import { movedText, movesFor, peerDiffReader } from './moved.mjs';
 import { isMarkdownFile, packSections, sectionFindings, sectionGroups } from './sections.mjs';
 import { FINDING_SCHEMA, minTokensOut, validateReview } from './validate-review.mjs';
 import { spawnWithTimeoutRetry } from './session-retry.mjs';
@@ -160,6 +167,10 @@ export function rulesRisk({ file, plusCount, cfg }) {
  * @property {string} [kind] - the block kind (`code`, `docs`, `contract`; B34); absent ⇒ `blockKind` of the reviewed file.
  * @property {string} [rulesDigest] @property {string} [factsExcerpt]
  * @property {string} workDir - where packet files are written (under the run's temp root).
+ * @property {ReadonlyArray<string>} [peers] - B56: the block's OTHER changed files (repo-relative);
+ *   code moved between this file and one of them is named in every packet (`## moved code`).
+ * @property {() => Promise<import('./moved.mjs').PeerDiff[]>} [peerDiffs] - B56: a memoised reader
+ *   of those files' diffs (`peerDiffReader`), shared by the caller across the round; wins over `peers`.
  */
 
 /**
@@ -212,6 +223,17 @@ export async function reviewFile(input, deps) {
   if (plan.refused) return { status: 'refused', reason: plan.refused, approved: false, ...head, sessions: [] };
   if (diff.diffText.trim().length === 0) return { status: 'no_change', approved: false, ...head, sessions: [] };
   mkdirSync(workDir, { recursive: true, mode: 0o700 });
+  // B56: the file's moves, read once; every packet and every measure of a part uses `movedOf`
+  /** @type {import('./moved.mjs').Moves | null} */
+  let moves = null;
+  try {
+    const peerDiffs = input.peerDiffs ?? peerDiffReader({ repoRoot, base: input.base, file: diff.file, peers: input.peers });
+    moves = await movesFor({ diff, peerDiffs });
+  } catch {
+    moves = null; // no hint; the review goes on
+  }
+  /** @param {ReadonlyArray<number> | null} keys - a Markdown section's group keys; null ⇒ the whole file. */
+  const movedOf = (keys) => movedText(moves, diff.content, keys);
   const min = minTokensOut(cfg);
   // B55: never in consensus mode — its providers (two reviewers, the judge) are the check itself
   const schemaFallback = plan.mode !== 'consensus';
@@ -237,16 +259,17 @@ export async function reviewFile(input, deps) {
 
   const reviewers = plan.sessions.filter((s) => s.role === 'reviewer');
   const judgeSpec = plan.sessions.find((s) => s.role === 'judge');
-  /** @param {import('./packet.mjs').FileDiff} part */
-  const packetsFor = (part) => reviewers.map((spec) => assemblePacket({ diff: part, lens: spec.lens, rulesDigest: input.rulesDigest, factsExcerpt: input.factsExcerpt, cfg }));
+  /** @param {import('./packet.mjs').FileDiff} part @param {ReadonlyArray<number> | null} [keys] */
+  const packetsFor = (part, keys = null) => reviewers.map((spec) => assemblePacket({ diff: part, lens: spec.lens, rulesDigest: input.rulesDigest, factsExcerpt: input.factsExcerpt, cfg, moved: movedOf(keys) }));
 
   /**
    * The plan on one packet set (the whole file, or one Markdown section): reviewers, then the judge.
    * @param {import('./packet.mjs').FileDiff} part @param {Array<Record<string, any>>} packets
    * @param {Record<string, any>} [rowExtra] - added to the `review.plan` row (`section`).
+   * @param {ReadonlyArray<number> | null} [keys] - the section's group keys (its moved-code hint).
    * @returns {Promise<{status: 'reviewed' | 'unavailable', reason?: string, approved: boolean, summary?: string, findings?: Array<Record<string, any>>, sessions: Array<Record<string, any>>}>}
    */
-  const reviewPart = async (part, packets, rowExtra = {}) => {
+  const reviewPart = async (part, packets, rowExtra = {}, keys = null) => {
     await note(deps, { event: 'review.plan', depth_unconstrained: plan.depth, depth_chosen: plan.depth, degrade_step: 0, risk, context_mode: packets[0]?.contextMode ?? null, forecast_tokens: packets.reduce((n, p) => n + p.tokensIn, 0), ...rowExtra });
     const done = await Promise.all(reviewers.map((spec, i) => run(spec, /** @type {any} */ (packets[i]))));
     const sessions = done.map(publicSummary);
@@ -258,7 +281,7 @@ export async function reviewFile(input, deps) {
     let final = done[0];
     if (judgeSpec) {
       const bySlot = Object.fromEntries(done.map((s) => [s.slot, s.review]));
-      const packet = assembleJudgePacket({ diff: part, reports: { A: bySlot.A, B: bySlot.B }, cfg });
+      const packet = assembleJudgePacket({ diff: part, reports: { A: bySlot.A, B: bySlot.B }, cfg, moved: movedOf(keys) });
       final = await runOne(judgeSpec, packet.text, packet, { deps, workDir, min, cfg, schemaFallback });
       sessions.push(publicSummary(final));
       if (final.status !== 'ok') {
@@ -281,18 +304,25 @@ export async function reviewFile(input, deps) {
   if (!isMarkdownFile(diff.file)) return { status: 'split_required', approved: false, ...head, tokens_in: split.tokensIn, budget: split.budget, sessions: [] };
 
   // B54: a Markdown file over the budget is reviewed section by section
-  /** @param {import('./packet.mjs').FileDiff} part @returns {number} the diff-only packet tokens, largest over the lenses. */
-  const measure = (part) => Math.max(...reviewers.map((spec) => diffOnlyTokens({ diff: part, lens: spec.lens })));
+  /**
+   * @param {import('./packet.mjs').FileDiff} part @param {ReadonlyArray<{key: number}> | null} [groups] - null ⇒ the whole file.
+   * @returns {number} the diff-only packet tokens, largest over the lenses.
+   */
+  const measure = (part, groups = null) => {
+    const moved = movedOf(groups === null ? null : groups.map((g) => g.key));
+    return Math.max(...reviewers.map((spec) => diffOnlyTokens({ diff: part, lens: spec.lens, moved })));
+  };
   const packed = packSections({ diff, budget: split.budget, measure });
   /**
    * A `split_required` outcome, its size always numeric (measured here when the packet lacks it).
    * @param {import('./packet.mjs').FileDiff} part @param {{tokensIn?: unknown, budget?: unknown}} over @param {string | null} section
+   * @param {ReadonlyArray<{key: number}> | null} [groups] - the part's heading groups (its moved-code hint); null ⇒ the whole file.
    */
-  const splitOutcome = (part, over, section) => ({
+  const splitOutcome = (part, over, section, groups = null) => ({
     status: 'split_required',
     approved: false,
     ...head,
-    tokens_in: Number.isFinite(over.tokensIn) ? over.tokensIn : measure(part),
+    tokens_in: Number.isFinite(over.tokensIn) ? over.tokensIn : measure(part, groups),
     budget: Number.isFinite(over.budget) ? over.budget : split.budget,
     ...(section ? { section } : {}),
     sessions: [],
@@ -300,7 +330,7 @@ export async function reviewFile(input, deps) {
   if (packed.status !== 'ok') {
     // a named section is measured on its own diff, never the whole file's
     const group = packed.section ? sectionGroups(diff)?.find((g) => g.heading === packed.section) : undefined;
-    return splitOutcome(group ? group.diff : diff, packed, packed.section);
+    return splitOutcome(group ? group.diff : diff, packed, packed.section, group ? [group] : null);
   }
   // never approve with no section: no packet ⇒ no session ⇒ split_required at the whole size
   if (packed.sections.length === 0) return splitOutcome(diff, split, null);
@@ -308,10 +338,10 @@ export async function reviewFile(input, deps) {
   // one measure, so with the real packer none is ever not `ok`: this is a DEFENSIVE guard (a test
   // reaches it through a mocked packer) — one that is not `ok` stops the file as split_required,
   // sized on that section's own diff
-  const sectionPackets = packed.sections.map((section) => packetsFor(section.diff));
+  const sectionPackets = packed.sections.map((section) => packetsFor(section.diff, section.keys));
   for (const [i, set] of sectionPackets.entries()) {
     const over = /** @type {{tokensIn?: unknown, budget?: unknown} | undefined} */ (set.find((p) => p.status !== 'ok'));
-    if (over) return splitOutcome(packed.sections[i].diff, over, packed.sections[i].headings[0] ?? '(before first heading)');
+    if (over) return splitOutcome(packed.sections[i].diff, over, packed.sections[i].headings[0] ?? '(before first heading)', packed.sections[i].keys.map((key) => ({ key })));
   }
   const sections = packed.sections.map((s) => ({ index: s.index, headings: s.headings, hunks: s.diff.hunks.length }));
   /** @type {Array<Record<string, any>>} */
@@ -321,7 +351,7 @@ export async function reviewFile(input, deps) {
   const summaries = [];
   let approved = true;
   for (const [i, section] of packed.sections.entries()) {
-    const part = await reviewPart(section.diff, sectionPackets[i], { section: section.index, sections: packed.sections.length });
+    const part = await reviewPart(section.diff, sectionPackets[i], { section: section.index, sections: packed.sections.length }, section.keys);
     sessions.push(...part.sessions.map((s) => ({ ...s, section: section.index })));
     if (part.status !== 'reviewed') return { status: part.status, reason: part.reason, approved: false, ...head, sections, sessions };
     approved = approved && part.approved;

package/src/review/fixloop.mjs

@@ -59,6 +59,15 @@
  * findings get ids `S<section>.<id>`; any section session unavailable ⇒ `retry` of the whole
  * round. A section still over the budget alone ⇒ the terminal stop above (`split_required`).
  *
+ * Moved code (B56): when `deps.peerDiffs` (or `deps.peers`) names the block's other changed files,
+ * every recheck and patch_check packet carries the file's `## moved code` section — computed from
+ * the file's diff against the block base (`deps.base`), never from the fix hunks, so a stale
+ * "feature deleted" finding on code that moved to another file meets the same hint as round 1. A
+ * Markdown section packet lists only the moves in its section. Sizing (`recheckTokens`,
+ * `packRecheck`) uses the same section text. The peers are read once per deps object (one ticket):
+ * the caller's `deps.peerDiffs` reader, else one memoised reader per deps (`recheckPeerDiffs`). Any
+ * failure there means no hint, never a failed recheck.
+ *
  * Schema misses (B55): a recheck (or patch_check) session whose answer fails the schema at its
  * packet's second miss is tried once on `review.second_levels.L2` when configured
  * (`schema-fallback.mjs`); only when that fails too is the round `unavailable` as below.
@@ -79,6 +88,7 @@ import { decisionProblem, grantCoverProblem } from './gate-check.mjs';
 import { contentHash, gitChildEnv } from '../worker/ticket.mjs';
 import { parseDiff } from './context.mjs';
 import { assemblePacket, assertPacketPath, diffOnlyTokens, readFileDiff } from './packet.mjs';
+import { movedText, movesFor, peerDiffReader } from './moved.mjs';
 import { isMarkdownFile, packSections, sectionFindings, sectionGroups, sectionOf } from './sections.mjs';
 import { cameFromJudge, resolvedBand, triageFindings } from './triage.mjs';
 import { FINDING_SCHEMA, minTokensOut, validateReview } from './validate-review.mjs';
@@ -128,7 +138,9 @@ import { afterSchemaMiss, logSecondLevelMiss } from './schema-fallback.mjs';
  * @property {(row: Record<string, any>) => Promise<unknown>} [writeRow]
  * @property {(req: {file: string, round: number, level: string, open: Finding[], l3_patch: boolean}) => Promise<unknown>} [fix] - a fresh coder session at `level`; `l3_patch` = the block's L3 patch is in the tree (§3.6).
  * @property {(req: {file: string, level: 'L3', open: Finding[]}) => Promise<unknown>} [patch] - the L3 patch rung (≤ 80 lines, owned files only).
- * @property {string | null} [base] - the block base (only for `recheck_scope: file`).
+ * @property {string | null} [base] - the block base (`recheck_scope: file`, and the B56 moved-code diff).
+ * @property {ReadonlyArray<string>} [peers] - B56: the block's other changed files (moved-code hints).
+ * @property {() => Promise<import('./moved.mjs').PeerDiff[]>} [peerDiffs] - B56: a memoised reader of their diffs (`peerDiffReader`); wins over `peers`.
  * @property {string} [rulesDigest] @property {string} [factsExcerpt]
  * @property {number} [extraRounds] - B47: rounds past `review.max_rounds_per_file` granted by autopilot (`extraRoundsFor`).
  * @property {import('./schema-fallback.mjs').SchemaHistory} [schemaHistory] - B55: the packet's signed schema-miss history; absent ⇒ no second-level try.
@@ -170,11 +182,14 @@ export function mergePacketInfo(info, packet) {
  * or hunks that do not parse one to one) ⇒ `split_required` at the whole size, never sectioned;
  * a finding no packet holds is listed in the LAST packet — every open finding is listed once.
  * @param {import('./packet.mjs').FileDiff} diff @param {Finding[]} open @param {number} budget
+ * @param {import('./moved.mjs').Moves | null} [moves] - the file's moves (B56): each candidate is sized
+ *   with the `## moved code` text of ITS sections (`movedText`), the whole size with all of them.
  * @returns {{status: 'ok', sections: Array<import('./sections.mjs').Section & {open: Finding[]}>} | {status: 'split_required', tokensIn: number, budget: number, section: string | null}}
  */
-export function packRecheck(diff, open, budget) {
+export function packRecheck(diff, open, budget, moves = null) {
+  const moved = movedText(moves, diff.content, null);
   const groups = sectionGroups(diff);
-  if (groups === null || groups.length === 0) return { status: 'split_required', tokensIn: recheckTokens(diff, open), budget, section: null };
+  if (groups === null || groups.length === 0) return { status: 'split_required', tokensIn: recheckTokens(diff, open, moved), budget, section: null };
   /** @type {Map<Finding, number>} */
   const keyOf = new Map();
   for (const f of open) {
@@ -183,10 +198,10 @@ export function packRecheck(diff, open, budget) {
   }
   /** @param {ReadonlyArray<number>} keys @returns {Finding[]} the open findings of those groups, in order. */
   const openIn = (keys) => open.filter((f) => keyOf.has(f) && keys.includes(/** @type {number} */ (keyOf.get(f))));
-  const packed = packSections({ diff, budget, measure: (part, set) => recheckTokens(part, openIn(set.map((g) => g.key))) });
+  const packed = packSections({ diff, budget, measure: (part, set) => (set === null ? recheckTokens(part, open, moved) : recheckTokens(part, openIn(set.map((g) => g.key)), movedText(moves, diff.content, set.map((g) => g.key)))) });
   if (packed.status !== 'ok') return packed;
   const sections = packed.sections.map((sec) => ({ ...sec, open: openIn(sec.keys) }));
-  if (sections.length === 0) return { status: 'split_required', tokensIn: recheckTokens(diff, open), budget, section: null };
+  if (sections.length === 0) return { status: 'split_required', tokensIn: recheckTokens(diff, open, moved), budget, section: null };
   // defensive: a finding no packet holds goes to the last packet (it is sized there by the check
   // every packet passes before any session) — never dropped, never closed unseen
   const listed = new Set(sections.flatMap((sec) => sec.open));
@@ -332,24 +347,77 @@ const openFindingsText = (open) => `${OPEN_FINDINGS_HEAD}${open.length > 0 ? ope
  * The size a recheck packet is held to (B54): its diff-only `recheck` packet (the measure behind
  * `split_required`) plus the open-findings list `buildRecheckPacket` appends. Section packing and
  * the check before any session use this ONE function.
- * @param {import('./packet.mjs').FileDiff} diff @param {ReadonlyArray<Finding>} open @returns {number}
+ * @param {import('./packet.mjs').FileDiff} diff @param {ReadonlyArray<Finding>} open
+ * @param {string} [moved] - the `## moved code` section the packet carries (B56).
+ * @returns {number}
  */
-export function recheckTokens(diff, open) {
-  return diffOnlyTokens({ diff, lens: 'recheck' }) + Math.ceil(Buffer.byteLength(openFindingsText(open)) / 4);
+export function recheckTokens(diff, open, moved = '') {
+  return diffOnlyTokens({ diff, lens: 'recheck', moved }) + Math.ceil(Buffer.byteLength(openFindingsText(open)) / 4);
 }
 
 /**
  * The recheck packet: the `recheck` lens on the fix hunks (hunk form, never the whole file), then
  * the open findings by id. Over budget ⇒ `minimal` (see the module doc).
- * @param {{diff: import('./packet.mjs').FileDiff, open: Finding[], cfg?: Record<string, any>, contextMode?: 'auto' | 'recheck', rulesDigest?: string, factsExcerpt?: string}} opts
+ * @param {{diff: import('./packet.mjs').FileDiff, open: Finding[], cfg?: Record<string, any>, contextMode?: 'auto' | 'recheck', rulesDigest?: string, factsExcerpt?: string, moved?: string}} opts -
+ *   `moved`: the file's `## moved code` section (B56), '' for none.
  */
-export function buildRecheckPacket({ diff, open, cfg, contextMode = 'recheck', rulesDigest, factsExcerpt }) {
-  const packet = assemblePacket({ diff, lens: 'recheck', cfg, contextMode, rulesDigest, factsExcerpt });
+export function buildRecheckPacket({ diff, open, cfg, contextMode = 'recheck', rulesDigest, factsExcerpt, moved = '' }) {
+  const packet = assemblePacket({ diff, lens: 'recheck', cfg, contextMode, rulesDigest, factsExcerpt, moved });
   if (packet.status !== 'ok') return packet;
   const text = `${packet.text}${openFindingsText(open)}`;
   return { ...packet, text, tokensIn: packet.tokensIn + Math.ceil(Buffer.byteLength(text.slice(packet.text.length)) / 4) };
 }
 
+/**
+ * B56: the peer readers built from `deps.peers` (no `deps.peerDiffs`): per deps object, one reader
+ * per (repoRoot, base, file, peers) key, so A → B → A on one deps reads A's peers once.
+ * @type {WeakMap<object, Map<string, () => Promise<import('./moved.mjs').PeerDiff[]>>>}
+ */
+const peerReaders = new WeakMap();
+
+/**
+ * The peers' diffs reader of a recheck: `deps.peerDiffs` when the caller gave one, else ONE
+ * memoised `peerDiffReader` per deps object and (repoRoot, base, file, peers) key, so the peers are
+ * read once however many rechecks run with the same deps (one ticket), whatever the order.
+ * @param {LoopDeps} deps @param {string} base @param {string} rel
+ * @returns {() => Promise<import('./moved.mjs').PeerDiff[]>}
+ */
+function recheckPeerDiffs(deps, base, rel) {
+  if (deps.peerDiffs) return deps.peerDiffs;
+  const key = JSON.stringify([deps.repoRoot, base, rel, deps.peers ?? null]);
+  let readers = peerReaders.get(deps);
+  if (!readers) {
+    readers = new Map();
+    peerReaders.set(deps, readers);
+  }
+  const known = readers.get(key);
+  if (known) return known;
+  const reader = peerDiffReader({ repoRoot: deps.repoRoot, base, file: rel, peers: deps.peers });
+  readers.set(key, reader);
+  return reader;
+}
+
+/**
+ * The recheck's moves (B56): from the file's diff against the block base (the one already read
+ * for `recheck_scope: file`, else read here), never from the fix hunks; the peers' diffs from the
+ * memoised reader (`recheckPeerDiffs`). No base, no peer, or ANY failure (building the reader
+ * included) ⇒ null: no hint, the recheck goes on.
+ * @param {LoopDeps} deps @param {string} rel @param {import('./packet.mjs').FileDiff | null} baseDiff
+ * @returns {Promise<import('./moved.mjs').Moves | null>}
+ */
+async function recheckMoves(deps, rel, baseDiff) {
+  try {
+    if (typeof deps.base !== 'string') return null;
+    const peerDiffs = recheckPeerDiffs(deps, deps.base, rel);
+    // nothing to read when there is no peer: the base diff is read only for a real peer set
+    if ((await peerDiffs()).length === 0) return null;
+    const diff = baseDiff ?? (await readFileDiff({ repoRoot: deps.repoRoot, file: rel, base: deps.base }));
+    return await movesFor({ diff, peerDiffs });
+  } catch {
+    return null;
+  }
+}
+
 /** @param {Finding} f @param {ReadonlyArray<Hunk>} hunks @returns {boolean} */
 export function insideHunks(f, hunks) {
   return hunks.some((h) => {
@@ -568,16 +636,17 @@ export async function runRound(state, deps, opts = {}) {
       draft.open = [];
       if (pending.length > 0) {
         const contextMode = s.scope === 'file' ? 'auto' : 'recheck';
-        const whole = buildRecheckPacket({ diff, open: pending, cfg: deps.cfg, contextMode, rulesDigest: deps.rulesDigest, factsExcerpt: deps.factsExcerpt });
-        /** @type {Array<{index: number | null, heading: string | null, diff: import('./packet.mjs').FileDiff, open: Finding[]}>} */
-        let parts = [{ index: null, heading: null, diff, open: pending }];
+        const moves = await recheckMoves(deps, current.rel, s.scope === 'file' ? diff : null);
+        const whole = buildRecheckPacket({ diff, open: pending, cfg: deps.cfg, contextMode, rulesDigest: deps.rulesDigest, factsExcerpt: deps.factsExcerpt, moved: movedText(moves, diff.content, null) });
+        /** @type {Array<{index: number | null, heading: string | null, diff: import('./packet.mjs').FileDiff, open: Finding[], keys: number[] | null}>} */
+        let parts = [{ index: null, heading: null, diff, open: pending, keys: null }];
         if (whole.status !== 'ok') {
           // deterministic (the same hunks build the same packet): terminal, never a retry — except
           // a Markdown file whose packet is `split_required`, rechecked section by section (B54);
           // any other status stops as it always did
-          const packed = whole.status === 'split_required' && isMarkdownFile(current.rel) ? packRecheck(diff, pending, whole.budget) : null;
+          const packed = whole.status === 'split_required' && isMarkdownFile(current.rel) ? packRecheck(diff, pending, whole.budget, moves) : null;
           if (!packed || packed.status !== 'ok') return stopBeforeRound(state, deps, kind, current.rel, packed ?? whole);
-          parts = packed.sections.map((sec) => ({ index: sec.index, heading: sec.headings[0], diff: sec.diff, open: sec.open }));
+          parts = packed.sections.map((sec) => ({ index: sec.index, heading: sec.headings[0], diff: sec.diff, open: sec.open, keys: sec.keys }));
         }
         // EVERY packet is built and held to the budget BEFORE any session runs: a section over it
         // stops the round as split_required (with its heading) before anything is spent
@@ -588,10 +657,11 @@ export async function runRound(state, deps, opts = {}) {
             built.push(whole);
             continue;
           }
-          const packet = buildRecheckPacket({ diff: part.diff, open: part.open, cfg: deps.cfg, contextMode, rulesDigest: deps.rulesDigest, factsExcerpt: deps.factsExcerpt });
+          const moved = movedText(moves, diff.content, part.keys);
+          const packet = buildRecheckPacket({ diff: part.diff, open: part.open, cfg: deps.cfg, contextMode, rulesDigest: deps.rulesDigest, factsExcerpt: deps.factsExcerpt, moved });
           // a packet that fails to build stops with ITS status (and size, when it has one)
           if (packet.status !== 'ok') return stopBeforeRound(state, deps, kind, current.rel, { ...packet, section: part.heading });
-          const size = recheckTokens(part.diff, part.open);
+          const size = recheckTokens(part.diff, part.open, moved);
           if (size > whole.budget) return stopBeforeRound(state, deps, kind, current.rel, { status: 'split_required', tokensIn: size, budget: whole.budget, section: part.heading });
           built.push(packet);
         }

package/src/review/moved.mjs

@@ -0,0 +1,399 @@
+/**
+ * Moved code across the files of one block (B56, issue #2).
+ *
+ * Each changed file is reviewed alone, so a block that moves code from file A to file B shows A's
+ * reviewer only removed lines — read as "feature deleted", a critical that came back on every
+ * recheck. This module finds, deterministically and without any model call, the removed runs of
+ * one file that were ADDED in another changed file of the same block (both diffed against the
+ * same block base), and the reverse, and renders them as the packet's `## moved code` section.
+ * The section is extra text only: every hunk still goes to the reviewer and `reviewed_hunks` is
+ * unchanged. A move inside ONE file (removed in one hunk, added in another) is not detected.
+ *
+ * Detection rule:
+ *  - a diff line is NORMALISED by trimming it and collapsing every whitespace run to one space;
+ *  - a line is SIGNIFICANT when its normalised form holds at least {@link MIN_LINE_ALNUM} letters
+ *    or digits — blank lines, lone braces/brackets/`});`, `*` comment rules are not;
+ *  - a RUN is a maximal sequence of adjacent `-` (or `+`) lines in one hunk; its significant lines
+ *    are compared in order, the trivial ones skipped (they never break a match);
+ *  - a removed run of this file matches an added run of a peer (and an added run of this file a
+ *    removed run of a peer) where their significant lines are EQUAL one after the other; the longest
+ *    such stretch from each removed line wins (ties: the first peer in sorted order, then the first
+ *    line), and it counts as moved when it has at least {@link MIN_MOVED_LINES} significant lines
+ *    or at least {@link MIN_MOVED_CHARS} significant characters (normalised lengths summed);
+ *  - line numbers are the BASE numbering for removed lines and the current numbering for added
+ *    lines; a range runs from the first to the last significant line of the stretch.
+ *
+ * Peers are read ONCE per review (`peerDiffReader`, memoised): one `git ls-tree <base>` (which
+ * peers exist in the base — a peer deleted in the block, staged or not, is diffed against the base
+ * with every line removed), one `git diff <base>` over those, one `git check-ignore` and one
+ * `git diff --no-index` per new peer on disk.
+ * Every peer diff is read with `a/`/`b/` prefixes forced (whatever `diff.noprefix` or
+ * `diff.mnemonicPrefix` say) and under the {@link MAX_DIFF_BYTES} cap: the listing over the cap is
+ * re-read peer by peer, and a peer over the cap alone is skipped — never buffered past the cap.
+ *
+ * Markdown section packets (B54) carry only the moves that fall in the section: each move has a
+ * position in the CURRENT file — an added stretch: its first line; a removed stretch: the current
+ * line just BEFORE the cut (0 at the top), so a block cut right above a heading belongs to the
+ * section that holds its removed hunk, exactly as `sectionGroups` cuts the hunks — and a section
+ * holds the positions under its headings.
+ *
+ * The section lists at most {@link MAX_MOVED_ENTRIES} ranges (then one "N more" line), so its size
+ * is capped; it counts toward the packet budget like any other section (`packet.mjs`).
+ */
+
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { exec } from '../util/exec.mjs';
+import { assertPacketPath, isSecretLike, plainGitEnv, reviewGitEnv } from './packet.mjs';
+import { markdownHeadings } from './sections.mjs';
+
+/** A significant line has at least this many letters or digits once normalised. */
+export const MIN_LINE_ALNUM = 4;
+/** A moved stretch has at least this many significant lines … */
+export const MIN_MOVED_LINES = 3;
+/** … or at least this many significant characters (normalised lengths summed). */
+export const MIN_MOVED_CHARS = 120;
+/** The section lists at most this many ranges. */
+export const MAX_MOVED_ENTRIES = 12;
+/** At most this many peer files are read for one file. */
+export const MAX_PEERS = 50;
+/** A peer (or own) diff larger than this many bytes is not scanned. */
+export const MAX_DIFF_BYTES = 2 * 1024 * 1024;
+
+/** At most this many peer positions are tried for one line (a very common line stays cheap). */
+const MAX_CANDIDATES = 200;
+const GIT_TIMEOUT_MS = 30000;
+/**
+ * `git diff` for a peer: `a/`/`b/` prefixes forced (the chunks are matched on them), whatever the
+ * repository's `diff.noprefix` / `diff.mnemonicPrefix` say; non-ASCII names unquoted
+ * (`core.quotePath=false`; a name git still quotes is never a peer — `printable`); no colour, no
+ * external diff.
+ */
+export const GIT_DIFF = Object.freeze(['git', '-c', 'core.quotePath=false', '-c', 'diff.noprefix=false', '-c', 'diff.mnemonicPrefix=false', 'diff', '--no-color', '--no-ext-diff', '--src-prefix=a/', '--dst-prefix=b/']);
+
+/** The `## moved code` section heading. */
+export const MOVED_HEAD = '## moved code';
+
+const ALNUM = /[\p{L}\p{N}]/gu;
+/**
+ * A path printed in the packet may not carry a control character (it could forge a section or
+ * reorder the text): C0, DEL, C1, the line/paragraph separators and the bidi controls.
+ */
+const CONTROL = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\u200e\u200f\u202a-\u202e\u2066-\u2069]/;
+/** … nor a character git quotes in a diff header even with `core.quotePath=false` (`"`, `\`). */
+const QUOTED = /["\\]/;
+
+/** @param {unknown} p @returns {boolean} whether `p` may be printed and matched as a peer path. */
+const printable = (p) => typeof p === 'string' && !CONTROL.test(p) && !QUOTED.test(p);
+
+/** @param {string} line @returns {string} */
+export const normaliseLine = (line) => line.trim().replace(/\s+/g, ' ');
+
+/** @param {string} norm @returns {boolean} */
+export const isSignificant = (norm) => (norm.match(ALNUM)?.length ?? 0) >= MIN_LINE_ALNUM;
+
+/**
+ * @typedef {{line: number, norm: string, at: number}} SigLine - `line`: its number on its own side;
+ *   `at`: its position in the current file (a removed line: the current line just before the cut, 0 at the top).
+ */
+/** @typedef {SigLine[]} Run - the significant lines of one run, in order. */
+/** @typedef {{file: string, diffText: string}} PeerDiff */
+
+/**
+ * The removed and added runs of one unified diff (one file), significant lines only.
+ * @param {string} diffText @returns {{removed: Run[], added: Run[]}}
+ */
+export function diffRuns(diffText) {
+  /** @type {Run[]} */
+  const removed = [];
+  /** @type {Run[]} */
+  const added = [];
+  if (typeof diffText !== 'string' || Buffer.byteLength(diffText) > MAX_DIFF_BYTES) return { removed, added };
+  const lines = diffText.split('\n');
+  const first = lines.findIndex((l) => l.startsWith('@@'));
+  if (first < 0) return { removed, added };
+  let oldNo = 0;
+  let newNo = 0;
+  /** @type {'-' | '+' | null} */
+  let open = null;
+  /** @type {Run} */
+  let run = [];
+  const close = () => {
+    if (open === '-' && run.length > 0) removed.push(run);
+    if (open === '+' && run.length > 0) added.push(run);
+    open = null;
+    run = [];
+  };
+  for (const line of lines.slice(first)) {
+    const m = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,(\d+))? @@/.exec(line);
+    if (m) {
+      close();
+      oldNo = Number(m[1]);
+      // an empty new side names the line BEFORE the change: the cut sits after it
+      newNo = m[3] === '0' ? Number(m[2]) + 1 : Number(m[2]);
+      continue;
+    }
+    const sign = line[0];
+    if (sign !== '-' && sign !== '+') {
+      close();
+      // a context line advances both sides; `` advances none
+      if (sign === ' ') {
+        oldNo += 1;
+        newNo += 1;
+      }
+      continue;
+    }
+    if (open !== sign) close();
+    open = sign;
+    const at = newNo - 1;
+    const no = sign === '-' ? oldNo++ : newNo++;
+    const norm = normaliseLine(line.slice(1));
+    if (isSignificant(norm)) run.push({ line: no, norm, at: sign === '-' ? at : no });
+  }
+  close();
+  return { removed, added };
+}
+
+/**
+ * @typedef {object} MoveMatch
+ * @property {number} start - first significant line of the stretch in THIS file (its own side).
+ * @property {number} end
+ * @property {number} at - its position in the current file (section filtering).
+ * @property {string} peer - the other file.
+ * @property {number} peerStart
+ * @property {number} peerEnd
+ */
+
+/** @typedef {{out: MoveMatch[], into: MoveMatch[]}} Moves */
+
+/**
+ * The moved stretches of `own` runs found in the `peers` runs (see the module doc).
+ * @param {Run[]} own @param {Array<{file: string, runs: Run[]}>} peers @returns {MoveMatch[]}
+ */
+export function matchRuns(own, peers) {
+  /** @type {Map<string, Array<{p: number, r: number, i: number}>>} */
+  const index = new Map();
+  peers.forEach((peer, p) =>
+    peer.runs.forEach((run, r) =>
+      run.forEach((sig, i) => {
+        const at = index.get(sig.norm);
+        if (at) at.push({ p, r, i });
+        else index.set(sig.norm, [{ p, r, i }]);
+      }),
+    ),
+  );
+  /** @type {MoveMatch[]} */
+  const out = [];
+  for (const run of own) {
+    let k = 0;
+    while (k < run.length) {
+      let best = { len: 0, chars: 0, p: -1, r: -1, i: -1 };
+      for (const c of (index.get(run[k].norm) ?? []).slice(0, MAX_CANDIDATES)) {
+        const target = peers[c.p].runs[c.r];
+        let len = 0;
+        let chars = 0;
+        while (k + len < run.length && c.i + len < target.length && run[k + len].norm === target[c.i + len].norm) {
+          chars += run[k + len].norm.length;
+          len += 1;
+        }
+        if (len > best.len) best = { len, chars, ...c };
+      }
+      if (best.len > 0 && (best.len >= MIN_MOVED_LINES || best.chars >= MIN_MOVED_CHARS)) {
+        const target = peers[best.p].runs[best.r];
+        out.push({ start: run[k].line, end: run[k + best.len - 1].line, at: run[k].at, peer: peers[best.p].file, peerStart: target[best.i].line, peerEnd: target[best.i + best.len - 1].line });
+        k += best.len;
+      } else {
+        k += 1;
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * The moves between one file's diff and its peers' diffs (pure).
+ * @param {{diff: {diffText: string}, peers: ReadonlyArray<PeerDiff>}} opts @returns {Moves}
+ */
+export function movedCode({ diff, peers }) {
+  const others = [...peers]
+    .filter((p) => printable(p.file))
+    .sort((a, b) => (a.file < b.file ? -1 : a.file > b.file ? 1 : 0))
+    .slice(0, MAX_PEERS)
+    .map((p) => ({ file: p.file, runs: diffRuns(p.diffText) }));
+  if (others.length === 0) return { out: [], into: [] };
+  const own = diffRuns(diff.diffText);
+  return {
+    out: matchRuns(own.removed, others.map((p) => ({ file: p.file, runs: p.runs.added }))),
+    into: matchRuns(own.added, others.map((p) => ({ file: p.file, runs: p.runs.removed }))),
+  };
+}
+
+/** @param {number} a @param {number} b @returns {string} */
+const range = (a, b) => (a === b ? `${a}` : `${a}-${b}`);
+
+/**
+ * The `## moved code` section for these moves: '' when there is none.
+ * @param {Moves} moves @returns {string}
+ */
+export function renderMoved({ out, into }) {
+  if (out.length === 0 && into.length === 0) return '';
+  const entries = [
+    ...out.map((m) => `- base lines ${range(m.start, m.end)} removed here were added in ${m.peer} lines ${range(m.peerStart, m.peerEnd)} in this block.`),
+    ...into.map((m) => `- lines ${range(m.start, m.end)} were moved here from ${m.peer} (its base lines ${range(m.peerStart, m.peerEnd)}) in this block.`),
+  ];
+  const shown = entries.slice(0, MAX_MOVED_ENTRIES);
+  if (entries.length > shown.length) shown.push(`- (${entries.length - shown.length} more moved ranges not listed)`);
+  const advice = [];
+  if (out.length > 0) advice.push('Do not report the removal of moved lines itself as a defect; review only whether references and imports are updated.');
+  if (into.length > 0) advice.push('Moved-in lines are reviewed in their new place like any change (imports, references, behaviour).');
+  return [MOVED_HEAD, ...shown, ...advice].join('\n');
+}
+
+/**
+ * The `## moved code` section for one file (pure): '' when nothing moved.
+ * @param {{diff: {diffText: string}, peers: ReadonlyArray<PeerDiff>}} opts @returns {string}
+ */
+export function movedSection(opts) {
+  return renderMoved(movedCode(opts));
+}
+
+/** One-entry cache: `markdownHeadings` of the last content asked (packing asks many times). */
+let headingCache = { content: /** @type {string | null | undefined} */ (undefined), keys: /** @type {number[]} */ ([]) };
+
+/** @param {string | null} content @returns {number[]} the heading lines, ascending. */
+function headingLines(content) {
+  if (headingCache.content !== content) headingCache = { content, keys: [...markdownHeadings(content).keys()].sort((a, b) => a - b) };
+  return headingCache.keys;
+}
+
+/**
+ * The section text a packet carries. `keys` null ⇒ every move (a whole-file packet: the ONE
+ * whole-file sentinel); an array ⇒ only the moves whose current-file position falls under one of
+ * those heading groups (`SectionGroup.key`: the heading line, 0 = before the first heading) — an
+ * empty array, or no move there, ⇒ ''.
+ * @param {Moves | null | undefined} moves @param {string | null} content - the CURRENT file.
+ * @param {ReadonlyArray<number> | null} [keys]
+ * @returns {string}
+ */
+export function movedText(moves, content, keys = null) {
+  if (!moves) return '';
+  if (keys === null) return renderMoved(moves);
+  const heads = headingLines(content);
+  /** @param {MoveMatch} m */
+  const inKeys = (m) => {
+    let key = 0;
+    for (const h of heads) if (h <= m.at) key = h;
+    return keys.includes(key);
+  };
+  return renderMoved({ out: moves.out.filter(inKeys), into: moves.into.filter(inKeys) });
+}
+
+/**
+ * The block's other changed files' diffs against `base`, read with as few git calls as possible
+ * (see the module doc). A peer that is not a plain repo path, is secret-like, ignored, unchanged,
+ * whose diff is over {@link MAX_DIFF_BYTES}, or whose diff cannot be split out of the listing gives
+ * nothing. Throws only when `git ls-tree` or `git check-ignore` fails.
+ * @param {{repoRoot: string, base: string, file: string, peers: ReadonlyArray<string>}} opts
+ * @returns {Promise<PeerDiff[]>}
+ */
+export async function readPeerDiffs({ repoRoot, base, file, peers }) {
+  if (base.length === 0 || base.startsWith('-')) return [];
+  /** @type {string[]} */
+  const rels = [];
+  for (const p of [...new Set(peers)].sort()) {
+    if (!printable(p) || p === file) continue;
+    try {
+      const rel = assertPacketPath(repoRoot, p);
+      if (!isSecretLike(rel)) rels.push(rel);
+    } catch {
+      // not a plain repo file ⇒ no hint from it
+    }
+    if (rels.length >= MAX_PEERS) break;
+  }
+  if (rels.length === 0) return [];
+  const env = reviewGitEnv();
+  const cap = { maxBufferBytes: MAX_DIFF_BYTES };
+  // "in base" (not "in the index"): a peer deleted in the block — `git rm` or gone from the
+  // working tree — is still diffed against the base, every line removed
+  const listed = await exec(['git', '-c', 'core.quotePath=false', 'ls-tree', '-r', '-z', '--name-only', base, '--', ...rels], { cwd: repoRoot, env, timeoutMs: GIT_TIMEOUT_MS });
+  if (listed.result !== 'ok') throw new Error('git ls-tree failed');
+  const inBase = new Set(listed.stdout.split('\0').filter((f) => f.length > 0));
+  /** @type {PeerDiff[]} */
+  const out = [];
+  const trackedRels = rels.filter((r) => inBase.has(r));
+  if (trackedRels.length > 0) {
+    /** @param {string[]} files */
+    const listing = (files) => exec([...GIT_DIFF, '--no-renames', base, '--', ...files], { cwd: repoRoot, env, timeoutMs: GIT_TIMEOUT_MS, ...cap });
+    /** @param {string} stdout @param {string[]} files - one chunk per file, named by its exact `diff --git a/<f> b/<f>` line (a quoted name matches none) */
+    const take = (stdout, files) => {
+      const chunks = stdout.split(/^(?=diff --git )/m);
+      for (const rel of files) {
+        const chunk = chunks.find((c) => c.startsWith(`diff --git a/${rel} b/${rel}\n`));
+        if (chunk && chunk.trim().length > 0) out.push({ file: rel, diffText: chunk });
+      }
+    };
+    const res = await listing(trackedRels);
+    if (res.result === 'ok') take(res.stdout, trackedRels);
+    else if (trackedRels.length > 1) {
+      // the listing is over the cap (or failed): peer by peer, one over the cap alone is skipped
+      // (a single peer's failed listing is that skip already)
+      for (const rel of trackedRels) {
+        const one = await listing([rel]);
+        if (one.result === 'ok') take(one.stdout, [rel]);
+      }
+    }
+  }
+  // absent from the base: a new file, read from disk (`--no-index`) unless git ignores it
+  const untracked = rels.filter((r) => !inBase.has(r) && existsSync(path.join(repoRoot, r)));
+  if (untracked.length > 0) {
+    // `check-ignore` refuses the literal-pathspec magic: plain env (no glob, no leading `:` here);
+    // the paths go on stdin, NUL-separated (`-z` needs `--stdin`)
+    const ignored = await exec(['git', 'check-ignore', '-z', '--stdin'], { cwd: repoRoot, env: plainGitEnv(), timeoutMs: GIT_TIMEOUT_MS, okExitCodes: [0, 1], input: `${untracked.join('\0')}\0` });
+    if (ignored.result !== 'ok') throw new Error('git check-ignore failed');
+    const skip = new Set(ignored.stdout.split('\0'));
+    for (const rel of untracked.filter((r) => !skip.has(r))) {
+      const res = await exec([...GIT_DIFF, '--no-index', '--', '/dev/null', rel], { cwd: repoRoot, env, timeoutMs: GIT_TIMEOUT_MS, okExitCodes: [0, 1], ...cap });
+      if (res.result === 'ok' && res.stdout.trim().length > 0) out.push({ file: rel, diffText: res.stdout });
+    }
+  }
+  return out.sort((a, b) => (a.file < b.file ? -1 : 1));
+}
+
+/**
+ * A memoised reader of the peers' diffs: the listing runs at most ONCE however often it is asked
+ * (one per ticket round: round 1, every section, the recheck). No base or no peer ⇒ []; a git
+ * failure ⇒ [] (no hint, the review goes on).
+ * @param {{repoRoot: string, base: string | null | undefined, file: string, peers?: ReadonlyArray<string>}} opts
+ * @returns {() => Promise<PeerDiff[]>}
+ */
+export function peerDiffReader({ repoRoot, base, file, peers }) {
+  /** @type {Promise<PeerDiff[]> | null} */
+  let once = null;
+  return () => {
+    if (once === null) {
+      once =
+        typeof base !== 'string' || !Array.isArray(peers) || peers.length === 0
+          ? Promise.resolve([])
+          : readPeerDiffs({ repoRoot, base, file, peers }).catch(() => []);
+    }
+    return once;
+  };
+}
+
+/**
+ * This file's moves, from its diff against the base and the peers' diffs. Never throws: any
+ * failure ⇒ null (no section).
+ * @param {{diff: {diffText: string}, peerDiffs?: () => Promise<PeerDiff[]>}} opts
+ * @returns {Promise<Moves | null>}
+ */
+export async function movesFor({ diff, peerDiffs }) {
+  if (!peerDiffs) return null;
+  try {
+    const peers = await peerDiffs();
+    if (peers.length === 0) return null;
+    const moves = movedCode({ diff, peers });
+    return moves.out.length + moves.into.length > 0 ? moves : null;
+  } catch {
+    return null;
+  }
+}

package/src/review/packet.mjs

@@ -10,6 +10,7 @@
  *   ## project rules   the rules digest (≤ 60 lines)
  *   ## facts           the facts-sheet excerpt
  *   ## context         the current file (whole, or hunk windows — `context.mjs`)
+ *   ## moved code      only when code moved to/from another file of the block (`moved.mjs`, B56)
  *   ## diff            `file:`, the `hunks:` list the reviewer must echo, then the diff
  *
  * Diff source (§4.1): a file in the index is diffed against the block's base SHA
@@ -20,7 +21,8 @@
  * bytes / 4. A diff that alone exceeds it ⇒ `split_required` (a Markdown file is then reviewed
  * section by section — `sections.mjs`, B54). Otherwise over budget ⇒ the context shrinks to
  * ± `min_context_lines` (`minimal`) FIRST, then the digest is trimmed from the end; the diff is
- * never cut.
+ * never cut. The `## moved code` section (B56) is part of that measure: it is counted in the diff-only
+ * size (`diffOnlyTokens`, `split_required`) and never trimmed.
  *
  * Path rule (V4): `file` is repo-root-relative; `./`, `../`, absolute values, symlinks and paths
  * under `.git/` or `.code-forge/` are refused with `bad-path` before git runs. So is anything git
@@ -54,10 +56,13 @@ const PATHSPEC_MAGIC = /[*?[\]]/;
 const SECRET_LIKE = [/(^|\/)\.env[^/]*$/i, /\.pem$/i, /\.key$/i, /\.p12$/i, /(^|\/)id_(rsa|ed25519|ecdsa)[^/]*$/i, /(^|\/)credentials[^/]*$/i, /(^|\/)\.code-forge(\/|$)/i];
 
 /** @param {string} rel @returns {boolean} */
-const isSecretLike = (rel) => SECRET_LIKE.some((re) => re.test(rel));
+export const isSecretLike = (rel) => SECRET_LIKE.some((re) => re.test(rel));
 
 /** The env for every child git in this module: B11's clean env plus literal pathspecs. */
-const reviewGitEnv = () => ({ ...gitChildEnv(), GIT_LITERAL_PATHSPECS: '1' });
+export const reviewGitEnv = () => ({ ...gitChildEnv(), GIT_LITERAL_PATHSPECS: '1' });
+
+/** B11's clean env alone: for `git check-ignore`, which refuses the literal-pathspec magic. */
+export const plainGitEnv = () => gitChildEnv();
 
 /** A refusal with a stable `code`: `bad-path`, `bad-lens`, `git`. */
 export class PacketError extends Error {
@@ -185,49 +190,50 @@ export async function readFileDiff({ repoRoot, file, base }) {
  * Assemble a reviewer packet (pure).
  * @param {{
  *   diff: FileDiff, lens: string, rulesDigest?: string, factsExcerpt?: string,
- *   cfg?: Record<string, any>, contextMode?: 'auto' | 'recheck', budget?: number,
- * }} opts
+ *   cfg?: Record<string, any>, contextMode?: 'auto' | 'recheck', budget?: number, moved?: string,
+ * }} opts - `moved`: the file's `## moved code` section (`moved.mjs`), '' for none.
  * @returns {Packet | {status: 'split_required', tokensIn: number, budget: number}}
  */
-export function assemblePacket({ diff, lens, rulesDigest = '', factsExcerpt = '', cfg, contextMode = 'auto', budget }) {
+export function assemblePacket({ diff, lens, rulesDigest = '', factsExcerpt = '', cfg, contextMode = 'auto', budget, moved = '' }) {
   const lensText = loadLens(lens);
   const limit = budget ?? budgetFor(cfg, lens === 'quick' ? 'quick_in' : 'full_in');
   const hunkHeaders = diff.hunks.map((h) => h.header);
   const diffSection = diffSectionOf(diff);
-  const bare = bareTokens(lensText, diffSection);
+  const bare = bareTokens(lensText, diffSection, moved);
   if (bare > limit) return { status: 'split_required', tokensIn: bare, budget: limit };
 
   let digest = splitLines(rulesDigest).slice(0, DIGEST_MAX_LINES);
   let ctx = buildContext({ file: diff.file, content: diff.content, hunks: diff.hunks, cfg, mode: contextMode });
-  let text = render(lensText, digest, factsExcerpt, ctx.text, diffSection);
+  let text = render(lensText, digest, factsExcerpt, ctx.text, diffSection, moved);
   if (estimateTokens(text) > limit) {
     ctx = buildContext({ file: diff.file, content: diff.content, hunks: diff.hunks, cfg, mode: 'minimal' });
-    text = render(lensText, digest, factsExcerpt, ctx.text, diffSection);
+    text = render(lensText, digest, factsExcerpt, ctx.text, diffSection, moved);
   }
   while (estimateTokens(text) > limit && digest.length > 0) {
     digest = digest.slice(0, -1);
-    text = render(lensText, digest, factsExcerpt, ctx.text, diffSection);
+    text = render(lensText, digest, factsExcerpt, ctx.text, diffSection, moved);
   }
   const tokensIn = estimateTokens(text);
   return { status: 'ok', text, hunkHeaders, contextMode: ctx.mode, contextLines: ctx.lineCount, digestLines: digest.length, tokensIn, budget: limit, overBudget: tokensIn > limit };
 }
 
 /**
- * The tokens of the diff-only packet (lens + diff, no digest, facts or context): what
- * `assemblePacket` holds against the budget before it says `split_required`.
- * @param {{diff: FileDiff, lens: string}} opts @returns {number}
+ * The tokens of the diff-only packet (lens + moved code + diff, no digest, facts or context): what
+ * `assemblePacket` holds against the budget before it says `split_required`. Pass the SAME `moved`
+ * section the packet gets.
+ * @param {{diff: FileDiff, lens: string, moved?: string}} opts @returns {number}
  */
-export function diffOnlyTokens({ diff, lens }) {
-  return bareTokens(loadLens(lens), diffSectionOf(diff));
+export function diffOnlyTokens({ diff, lens, moved = '' }) {
+  return bareTokens(loadLens(lens), diffSectionOf(diff), moved);
 }
 
 /**
  * The ONE measure behind `split_required` (`assemblePacket`) and section packing (`diffOnlyTokens`,
  * B54), so the two can never disagree.
- * @param {string} lensText @param {string} diffSection @returns {number}
+ * @param {string} lensText @param {string} diffSection @param {string} moved @returns {number}
  */
-function bareTokens(lensText, diffSection) {
-  return estimateTokens(render(lensText, [], '', '', diffSection));
+function bareTokens(lensText, diffSection, moved) {
+  return estimateTokens(render(lensText, [], '', '', diffSection, moved));
 }
 
 /** @param {FileDiff} diff @returns {string} the `## diff` section body. */
@@ -237,9 +243,9 @@ function diffSectionOf(diff) {
 
 /**
  * @param {string} lensText @param {string[]} digest @param {string} facts @param {string} context
- * @param {string} diffSection
+ * @param {string} diffSection @param {string} [moved] - the `## moved code` section (heading included), '' for none.
  */
-function render(lensText, digest, facts, context, diffSection) {
+function render(lensText, digest, facts, context, diffSection, moved = '') {
   return [
     '# code-forge review packet',
     '## lens',
@@ -250,6 +256,7 @@ function render(lensText, digest, facts, context, diffSection) {
     facts.trim().length > 0 ? facts.trimEnd() : '(none)',
     '## context',
     context.length > 0 ? context : '(none)',
+    ...(moved.length > 0 ? [moved] : []),
     '## diff',
     diffSection,
     '',
@@ -271,11 +278,12 @@ export async function buildPacket(opts) {
 
 /**
  * The judge's packet (§4.2 step 3, §4.4): the judge lens, the hunk list, the two blind reports,
- * and the diff only when `review.judge_sees_diff` is true (R3, default false).
- * @param {{diff: FileDiff, reports: {A: unknown, B: unknown}, cfg?: Record<string, any>}} opts
+ * and the diff only when `review.judge_sees_diff` is true (R3, default false); the file's
+ * `## moved code` section (B56) before the diff when there is one.
+ * @param {{diff: FileDiff, reports: {A: unknown, B: unknown}, cfg?: Record<string, any>, moved?: string}} opts
  * @returns {{status: 'ok', text: string, hunkHeaders: string[], tokensIn: number, budget: number, contextMode: null}}
  */
-export function assembleJudgePacket({ diff, reports, cfg }) {
+export function assembleJudgePacket({ diff, reports, cfg, moved = '' }) {
   const hunkHeaders = diff.hunks.map((h) => h.header);
   const seesDiff = cfg?.review?.judge_sees_diff === true;
   const text = [
@@ -286,6 +294,7 @@ export function assembleJudgePacket({ diff, reports, cfg }) {
     JSON.stringify(reports.A, null, 1),
     '## reviewer B',
     JSON.stringify(reports.B, null, 1),
+    ...(moved.length > 0 ? [moved] : []),
     '## diff',
     [`file: ${diff.file}`, 'hunks:', ...hunkHeaders.map((h) => `- ${h}`), ...(seesDiff ? ['', diff.diffText.trimEnd()] : [])].join('\n'),
     '',

package/src/review/sections.mjs

@@ -203,14 +203,15 @@ function diffOf(diff, fileHeader, pieces) {
  * Pack the heading groups into section packets within `budget` (step 3 of the module doc). A
  * candidate's size is `measure(its diff, its groups)` (a recheck adds the open findings it lists
  * for those groups). Never `ok` with no section: a diff with no hunk, or one whose hunks do not
- * parse one to one, is `split_required` at `measure(diff, [])` with `section: null`.
- * @param {{diff: FileDiff, budget: number, measure: (diff: FileDiff, groups: SectionGroup[]) => number}} opts -
- *   `measure`: the packet tokens of a candidate (the largest over the session lenses).
+ * parse one to one, is `split_required` at `measure(diff, null)` with `section: null`.
+ * @param {{diff: FileDiff, budget: number, measure: (diff: FileDiff, groups: SectionGroup[] | null) => number}} opts -
+ *   `measure`: the packet tokens of a candidate (the largest over the session lenses); `groups`
+ *   null ⇒ the whole file (B56: its whole moved-code section), never an empty section.
  * @returns {{status: 'ok', sections: Section[]} | {status: 'split_required', tokensIn: number, budget: number, section: string | null}}
  */
 export function packSections({ diff, budget, measure }) {
   const groups = sectionGroups(diff);
-  if (groups === null || groups.length === 0) return { status: 'split_required', tokensIn: measure(diff, []), budget, section: null };
+  if (groups === null || groups.length === 0) return { status: 'split_required', tokensIn: measure(diff, null), budget, section: null };
   /** @param {SectionGroup[]} set */
   const size = (set) => measure(merge(diff, set), set);
   /** @type {Section[]} */

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';
@@ -206,19 +210,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, 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, 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[], file: string}} opts
+ * @returns {Promise<string[]>}
+ */
+export async function blockPeers(repoRoot, { base, owned, 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));
+  } 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[], file: string}} opts
+ * @returns {() => Promise<import('../review/moved.mjs').PeerDiff[]>}
+ */
+export function blockPeerDiffs(repoRoot, { base, owned, 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, 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 +326,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[], 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, 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>}} */
@@ -324,7 +369,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 +380,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 +433,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) => {