@codedology/code-forge 0.7.4 → 0.7.5

package/CHANGELOG.md

@@ -6,6 +6,19 @@ waits on a second real consumer (plan §10.4, Q17).
 
 ## [Unreleased]
 
+## [0.7.5] — 2026-10-08
+
+### Fixed
+
+- An owned entry with no glob character now owns every path below it everywhere, not only at `block close`: `block open`
+  and the plan check refuse a directory that overlaps a file or directory of another block (parent or child, either way
+  round; `src/feature` vs `src/featureX` stay disjoint), and `block claim`, `block rebase`, the scope gate, proof and
+  the worker's file set and budget count the files inside an owned directory (B57, issue #2). An entry that is a regular
+  file at `block open` or `block claim` owns only itself (recorded as `owned_kinds`); one not there yet stays
+  directory-like; a brace entry stays a glob. A refused `block claim` names the entry it overlaps
+  (`<path> overlaps <entry> owned by open block <id>`), and `proof export` never copies or removes an owned directory
+  itself, only the files in it.
+
 ## [0.7.4] — 2026-10-08
 
 ### Added

package/README.md

@@ -12,6 +12,14 @@ for cross-model, parallel, evidence-gated feature delivery — on Claude Code, C
 
 Next release:
 
+- **An owned directory owns the files inside it, everywhere.** A block that owns `src/feature`
+  now owns `src/feature/a.swift` for `block open`, `block claim`, `block rebase`, the scope gate,
+  proof and the review worker, not only for `block close`. `block open` refuses a second block
+  that owns a file or folder inside it (or a folder around it), so two coders can no longer edit
+  the same files at once. A path that is already a file when the block opens owns only itself.
+
+In 0.7.4:
+
 - **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

package/docs/reference/blocks.json

@@ -4,7 +4,7 @@
     "plans/code-forge-plan-v1.3.md §10.4",
     "plans/NIGHT-LOG.md"
   ],
-  "block_count": 59,
+  "block_count": 60,
   "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": {
@@ -810,6 +810,19 @@
         "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"
+    },
+    "B57": {
+      "title": "One ownership rule (issue #2): an owned entry with no glob character owns its path and every path below it (src/feature owns src/feature/a.swift, never src/featureX/a.swift) unless block open or block claim saw a regular file there (owned_kinds: then it owns only itself); globs, brace entries included, own what they match; findOverlap reports file/dir and dir/dir parent-child overlaps either way and a directory-like entry against a glob matching it or any path below it; the rule lives in src/state/registry.mjs and every caller uses it (block open, claim, rebase, scope gate, close gate, proof, worker file set and budget, plan check)",
+      "wave": 12,
+      "level": "L2",
+      "status": "landed",
+      "owned": [
+        "src/state/owned-kinds.mjs"
+      ],
+      "depends_on": [
+        "B56"
+      ],
+      "note": "root-added 2026-10-08; found while fixing GitHub issue #2 (B52); also amends src/state/{registry,block}.mjs, src/review/gate-check.mjs, src/cli/{block,proof,plan}.mjs, src/proof/{export,tiers}.mjs, src/worker/engine.mjs, src/session/plan-check.mjs, tests, docs/how-it-works.md, skill/references/code.md"
     }
   }
 }

package/package.json

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

package/skill/references/code.md

@@ -10,7 +10,7 @@ The coder then forecasts **cases** (tests) and **lines**. Compute the floor your
 
 ## §3 Dispatch — what the brief contains
 
-`forge block open <id> --run <r> --level L<n> --owned <paths…> --acceptance <file> --brief <file> [--attempt <n>] [--base <sha>] [--kind code|docs|contract] --lines <n>` records the base sha, the owned files (overlap with another active block ⇒ refused), the block kind (declared, else detected — `decisions.md` §5), the level (a docs/contract block below `levels.coder_floor_docs`, default L1, is raised to it and the CLI prints the floor), the clauses with their test ids and the forecast, writes the ledger `dispatch` row and prints the pointer `BRIEF <path> lines=<n> sha=<sha8> <<<EOM>>>` (≤ 200 B). Call it before every spawn, in every engine. A docs block that owns a glob (`docs/**`) must declare `--kind docs`: a glob is judged by its literal ending, so undeclared it counts as `code`. The brief file carries, in this order:
+`forge block open <id> --run <r> --level L<n> --owned <paths…> --acceptance <file> --brief <file> [--attempt <n>] [--base <sha>] [--kind code|docs|contract] --lines <n>` records the base sha, the owned files (overlap with another active block ⇒ refused; an owned entry with no glob character — `*`, `?`, `{` — owns that path and every path below it, so `src/feature` owns `src/feature/a.swift` but not `src/featureX/a.swift`, and `src/feature` overlaps `src/feature/x.swift` or `src` in another block — unless the entry is a regular file in the workspace at `block open` (or `block claim`): then it owns only itself, recorded as `owned_kinds`, and every later check reads that answer; a glob owns what it matches, and a brace entry `src/{a,b}` is a glob, so `src/a` owns nothing below it; no trailing `/`), the block kind (declared, else detected — `decisions.md` §5), the level (a docs/contract block below `levels.coder_floor_docs`, default L1, is raised to it and the CLI prints the floor), the clauses with their test ids and the forecast, writes the ledger `dispatch` row and prints the pointer `BRIEF <path> lines=<n> sha=<sha8> <<<EOM>>>` (≤ 200 B). Call it before every spawn, in every engine. A docs block that owns a glob (`docs/**`) must declare `--kind docs`: a glob is judged by its literal ending, so undeclared it counts as `code`. The brief file carries, in this order:
 
 1. `id`, `title`, the level, `owned_files` ("edit ONLY these"), the acceptance clauses with test ids, `test_command`.
 2. The reply contract: `ACK <sha8> lines=<n>` before any tool call; the facts diff; the forecast.

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.4"
+PINNED_VERSION="0.7.5"
 set -eu
 
 self="$0"

package/src/cli/block.mjs

@@ -218,7 +218,7 @@ export async function runBlock(args, deps = {}) {
           const real = async (/** @type {string} */ p) => realpath(p).catch(() => path.resolve(p));
           const wsPrefix = path.relative(await real(top), await real(record.workspace)).split(path.sep).join('/');
           const owns = ownsAt(wsPrefix);
-          const isMine = (/** @type {string} */ f) => owns(entry.owned_files, f);
+          const isMine = (/** @type {string} */ f) => owns(entry.owned_files, f, entry.owned_kinds);
           const changed = await changedFiles({ repoRoot: top, base: entry.base_sha });
           // the file set is the diff since base ∪ every owned file with review rows of this block —
           // work the diff cannot see (committed before `block open`, done in another worktree) is
@@ -238,7 +238,7 @@ export async function runBlock(args, deps = {}) {
         // B20: the high paths come first — a base the workspace does not know refuses the close here
         const highPaths = await highPathsAt(record.workspace, entry.base_sha);
         const { top, wsPrefix, owns, changed, fileSet, reviewed } = await tree();
-        const isMine = (/** @type {string} */ f) => owns(entry.owned_files, f);
+        const isMine = (/** @type {string} */ f) => owns(entry.owned_files, f, entry.owned_kinds);
         const key = await loadKey(runId);
         // B52: an empty diff with review rows is never silent — name the likely cause
         if (reviewed.length > 0 && !changed.some(isMine)) {

package/src/cli/plan.mjs

@@ -71,7 +71,7 @@ export async function runPlanVerb(args, deps = {}) {
     // package.json fails only the plans that depend on it
     let result;
     try {
-      result = checkPlan(text, { planPath, factsPath, factsText, cfg, decisions, projectBins: () => readProjectBins(root) });
+      result = checkPlan(text, { planPath, factsPath, factsText, cfg, decisions, root, projectBins: () => readProjectBins(root) });
     } catch (err) {
       if (!(err instanceof FactsError)) throw err;
       writeSafe(stderr, `plan: ${err.message}\n`);

package/src/cli/proof.mjs

@@ -36,7 +36,7 @@ import { acquireProofLock, lockHolder, releaseProofLock } from '../proof/lock.mj
 import { MECHANISMS, readJournal, restoreJournal, runRedGreen } from '../proof/red-green.mjs';
 import { tierFor } from '../proof/tiers.mjs';
 import { blockFileSet, repoRelativePath } from '../review/gate-check.mjs';
-import { findOverlap } from '../state/registry.mjs';
+import { ownsFile } from '../state/registry.mjs';
 
 const USAGE =
   'usage: code-forge proof tier --file <path> --risk <0-3> [--security] [--cwd <dir>]\n' +
@@ -126,6 +126,7 @@ async function exportAndRecord({ runId, record, blockId, block, config, writeRow
     blockId,
     baseSha: block.base_sha,
     owned: block.owned_files,
+    ownedKinds: block.owned_kinds,
     linkDirs: config?.proof?.export?.link_dirs ?? DEFAULT_LINK_DIRS,
     copyUntracked: config?.proof?.export?.copy_untracked ?? DEFAULT_COPY_UNTRACKED,
   });
@@ -243,7 +244,7 @@ export async function runProof(args, deps = {}) {
         repoRoot: record.workspace,
         base: block.base_sha,
         owned: block.owned_files,
-        matchOwned: (f) => findOverlap(block.owned_files, [f]) !== null,
+        matchOwned: (f) => ownsFile(block.owned_files, f, block.owned_kinds),
       });
       const sources = mechanism === 'assertion-deletion' ? [] : changed.map((c) => c.file).filter((f) => f !== file && !TEST_PATH.test(f));
       if (mechanism === 'revert' && sources.length === 0) {

package/src/proof/export.mjs

@@ -28,7 +28,7 @@ import { copyFile, lstat, mkdir, mkdtemp, readlink, realpath, rm, stat, symlink
 import path from 'node:path';
 import { runGates } from '../gates/run.mjs';
 import { StateError } from '../state/paths.mjs';
-import { ownsFile } from '../state/registry.mjs';
+import { isExactEntry, ownsFile } from '../state/registry.mjs';
 import { writeSigned } from '../state/run.mjs';
 import { exec } from '../util/exec.mjs';
 import { revParse } from '../util/git.mjs';
@@ -148,8 +148,16 @@ async function exportIgnoredBlobs(entries, base, cwd) {
 
 /**
  * Build (or rebuild) the export of one block.
+ *
+ * Owned paths follow the registry's one rule (B57): `ownedKinds` is the block's `owned_kinds` from
+ * the run record — every caller passes it; left out it is `{}`, so every exact entry is
+ * directory-like (fail closed: it owns the paths below it). A path's kind may differ between base
+ * and the tree: a base FILE where the tree has a directory leaves the export before the files below
+ * it are copied, and a base DIRECTORY where the tree has a file leaves with every base blob in it;
+ * each base blob that leaves is listed in `removed`. A directory is never removed whole because
+ * it is owned or missing: only the blobs below it, one by one.
  * @param {{
- *   cwd: string, blockId: string, baseSha: string, owned: ReadonlyArray<string>,
+ *   cwd: string, blockId: string, baseSha: string, owned: ReadonlyArray<string>, ownedKinds?: Readonly<Record<string, string>>,
  *   linkDirs?: ReadonlyArray<string>, copyUntracked?: ReadonlyArray<string>, exportRoot?: string,
  * }} opts
  * @returns {Promise<{dir: string, base: string, restored: string[], untracked: string[], owned: string[], removed: string[], linked: string[]}>}
@@ -206,21 +214,54 @@ export async function buildExport(opts) {
 
     // (d) owned files at current content; owned base files deleted in the tree leave the export.
     const listed = (await git(['ls-files', '-z', '--cached', '--others', '--exclude-standard'], cwd)).split('\0').filter(Boolean);
-    const exact = owned.filter((o) => !/[*?{]/.test(o));
-    const candidates = [...new Set([...listed, ...exact, ...baseBlobs])].filter((f) => ownsFile(owned, f)).sort();
+    const exact = owned.filter((o) => isExactEntry(o));
+    const ownedKinds = opts.ownedKinds ?? {};
+    const candidates = [...new Set([...listed, ...exact, ...baseBlobs])].filter((f) => ownsFile(owned, f, ownedKinds)).sort();
+    const candidateSet = new Set(candidates);
     const ownedCopied = [];
-    const removed = [];
+    /** @type {Set<string>} */
+    const removedSet = new Set();
+    /** A base blob that is not in the tree at its path any more leaves the export: listed. */
+    const markRemoved = (/** @type {string} */ rel) => {
+      if (baseBlobs.has(rel)) removedSet.add(rel);
+    };
+    /** B57: an export entry above `rel` that is not a directory (a base file the tree turned into a directory) leaves. */
+    const clearParents = async (/** @type {string} */ rel) => {
+      const segments = rel.split('/');
+      for (let n = 1; n < segments.length; n += 1) {
+        const parent = segments.slice(0, n).join('/');
+        const at = await lstatOrNull(path.join(dir, parent));
+        if (at === null) return;
+        if (!at.isDirectory()) {
+          await rm(path.join(dir, parent), { force: true });
+          markRemoved(parent);
+          return;
+        }
+      }
+    };
     for (const rel of candidates) {
       assertRelPath(rel, 'owned files');
       const src = path.join(cwd, rel);
       const dest = path.join(dir, rel);
       const st = await lstatOrNull(src);
-      await rm(dest, { recursive: true, force: true });
-      if (st === null) {
-        if (baseBlobs.has(rel)) removed.push(rel);
+      const at = await lstatOrNull(dest);
+      // B57: nothing to copy — a path missing from the tree, or a directory (an exact owned entry may
+      // name one; its files are candidates of their own). A stale non-directory export entry there
+      // leaves; an export directory is never removed whole — its owned blobs leave one by one.
+      if (st === null || st.isDirectory()) {
+        if (at !== null && !at.isDirectory()) await rm(dest, { force: true });
+        markRemoved(rel);
         continue;
       }
+      if (at?.isDirectory()) {
+        // a base directory the tree turned into a file: every base blob in it is gone from the tree
+        for (const blob of baseBlobs) if (blob.startsWith(`${rel}/`) && !candidateSet.has(blob)) markRemoved(blob);
+        await rm(dest, { recursive: true, force: true });
+      } else if (at !== null) {
+        await rm(dest, { force: true });
+      }
       if (!st.isFile() && !st.isSymbolicLink()) continue;
+      await clearParents(rel);
       await mkdir(path.dirname(dest), { recursive: true });
       if (st.isSymbolicLink()) await symlink(await readlink(src), dest);
       else await copyFile(src, dest);
@@ -240,7 +281,7 @@ export async function buildExport(opts) {
       linked.push(rel);
     }
 
-    return { dir, base, restored: [...restored].sort(), untracked: untracked.sort(), owned: ownedCopied, removed, linked: linked.sort() };
+    return { dir, base, restored: [...restored].sort(), untracked: untracked.sort(), owned: ownedCopied, removed: [...removedSet].sort(), linked: linked.sort() };
   } finally {
     await rm(scratch, { recursive: true, force: true });
   }

package/src/proof/tiers.mjs

@@ -23,7 +23,8 @@ export const HIGH_RISK = 2;
 /**
  * @param {{file: string, risk: number, securitySensitive?: boolean, highPaths?: ReadonlyArray<string>}} input
  *   `risk` is the S1 `risk` answer (0–3); `highPaths` is `proof.tiers.high.paths` (exact paths or
- *   globs in the registry's syntax: `*`, `?`, `**`, `{a,b}`).
+ *   globs in the registry's syntax: `*`, `?`, `**`, `{a,b}`; an exact path also covers the paths
+ *   below it, B57).
  * @returns {{tier: Tier, reason: TierReason}} the FIRST reason that applies, in the order
  *   security, risk, path — every one of them yields `high`, so the order only picks the label.
  * @throws {TypeError} on a non-string file, a risk outside 0–3, or a non-array `highPaths`.

package/src/review/gate-check.mjs

@@ -68,7 +68,7 @@ import { mergeForbidden, scanTranscript } from '../util/forbidden.mjs';
 import { exec } from '../util/exec.mjs';
 import { readRun, writeSigned } from '../state/run.mjs';
 import { StateError } from '../state/paths.mjs';
-import { findOverlap } from '../state/registry.mjs';
+import { ownsFile } from '../state/registry.mjs';
 import { sameStamp, treeStamp } from '../state/block.mjs';
 import { verifyRow } from '../state/signer.mjs';
 import { tierFor } from '../proof/tiers.mjs';
@@ -565,15 +565,15 @@ export function repoRelativePath(raw) {
 
 /**
  * The block's file set (§4.1): changed tracked files since `base` (deletions included, hashed
- * `DELETED_HASH`) ∪ untracked files, filtered to `owned` (exact paths; a glob owned entry matches through `matchOwned`), each with its content hash.
+ * `DELETED_HASH`) ∪ untracked files, filtered to `owned` (`matchOwned`, default the registry's `ownsFile` with `ownedKinds`: an exact entry owns its path and the paths below it unless recorded as a regular file, B57), each with its content hash.
  * Every path goes through `repoRelativePath`.
- * @param {{repoRoot: string, base: string, owned: string[], matchOwned?: (file: string) => boolean, changed?: string[]}} opts
+ * @param {{repoRoot: string, base: string, owned: string[], ownedKinds?: Record<string, string>, matchOwned?: (file: string) => boolean, changed?: string[]}} opts
  *   `changed`: the tree's changed files when the caller already listed them ({@link changedFiles}).
  * @returns {Promise<Array<{file: string, content_hash: string}>>}
  */
-export async function blockFileSet({ repoRoot, base, owned, matchOwned, changed }) {
+export async function blockFileSet({ repoRoot, base, owned, ownedKinds, matchOwned, changed }) {
   const all = changed ?? (await changedFiles({ repoRoot, base }));
-  const isOwned = matchOwned ?? ((/** @type {string} */ f) => owned.includes(f));
+  const isOwned = matchOwned ?? ((/** @type {string} */ f) => ownsFile(owned, f, ownedKinds));
   return all.filter((f) => isOwned(f)).map((file) => ({ file, content_hash: currentHash(repoRoot, file) }));
 }
 
@@ -597,15 +597,16 @@ export async function changedFiles({ repoRoot, base }) {
 }
 
 /**
- * B52: whether `owned` (a block's `owned_files`) covers `file` at the gate: the `findOverlap`
- * match `block open` uses (exact paths and globs), and — what the field run needed — an entry with
- * no glob character also covers every path below it as a directory (`src/feature` owns
- * `src/feature/Fan.swift`). A wider match only ever puts more files under the gate's checks.
- * @param {ReadonlyArray<string>} owned @param {string} file @returns {boolean}
+ * B52: whether `owned` (a block's `owned_files`) covers `file` at the gate. B57: the registry's one
+ * ownership rule (`ownsFile`) — the rule `block open`, the scope gate and the worker use: an entry
+ * with no glob character covers its path and every path below it as a directory (`src/feature`
+ * owns `src/feature/Fan.swift`, never `src/featureX/B.swift`) unless `kinds` (the block's
+ * `owned_kinds`) recorded it as a regular file, a glob what it matches.
+ * @param {ReadonlyArray<string>} owned @param {string} file @param {Readonly<Record<string, string>>} [kinds]
+ * @returns {boolean}
  */
-export function ownsPath(owned, file) {
-  if (findOverlap(owned, [file]) !== null) return true;
-  return owned.some((o) => typeof o === 'string' && o.length > 0 && !/[*?[\]{}]/.test(o) && file.startsWith(`${o.replace(/\/+$/, '')}/`));
+export function ownsPath(owned, file, kinds) {
+  return ownsFile(owned, file, kinds);
 }
 
 /**
@@ -614,11 +615,11 @@ export function ownsPath(owned, file) {
  * given, or — for a workspace in a subdirectory (`wsPrefix`, the workspace relative to the top;
  * `''` when they are the same) — relative to the workspace. A file outside the workspace is
  * matched as given only.
- * @param {string} wsPrefix @returns {(owned: ReadonlyArray<string>, file: string) => boolean}
+ * @param {string} wsPrefix @returns {(owned: ReadonlyArray<string>, file: string, kinds?: Readonly<Record<string, string>>) => boolean}
  */
 export function ownsAt(wsPrefix) {
   const prefix = wsPrefix.replace(/\/+$/, '');
-  return (owned, file) => ownsPath(owned, file) || (prefix !== '' && prefix !== '.' && file.startsWith(`${prefix}/`) && ownsPath(owned, file.slice(prefix.length + 1)));
+  return (owned, file, kinds) => ownsPath(owned, file, kinds) || (prefix !== '' && prefix !== '.' && file.startsWith(`${prefix}/`) && ownsPath(owned, file.slice(prefix.length + 1), kinds));
 }
 
 /** B52: the review rows that name a file the block's worker reviewed. */
@@ -673,8 +674,8 @@ const currentHash = (repoRoot, file) => (isOnDisk(repoRoot, file) ? contentHash(
  * warns that the check did not run (never a silent pass).
  * @param {{
  *   top: string, changed: ReadonlyArray<string>, id: string, blocks: Record<string, any>,
- *   rows: Array<Record<string, any>>, key: Buffer, isMine: (file: string) => boolean, owns?: (owned: ReadonlyArray<string>, file: string) => boolean, stateDir?: string,
- * }} opts `blocks`: the run record's `blocks`; `rows`: the run's ledger rows; `owns` (default {@link ownsPath}): how another block's `owned_files` match a path.
+ *   rows: Array<Record<string, any>>, key: Buffer, isMine: (file: string) => boolean, owns?: (owned: ReadonlyArray<string>, file: string, kinds?: Readonly<Record<string, string>>) => boolean, stateDir?: string,
+ * }} opts `blocks`: the run record's `blocks`; `rows`: the run's ledger rows; `owns` (default {@link ownsPath}): how another block's `owned_files` (with its `owned_kinds`) match a path.
  * @returns {Promise<{unowned: string[], siblings: Array<{file: string, block: string}>} | null>}
  */
 export async function unownedChanges({ top, changed, id, blocks, rows, key, isMine, owns = ownsPath, stateDir = '.code-forge' }) {
@@ -692,7 +693,7 @@ export async function unownedChanges({ top, changed, id, blocks, rows, key, isMi
     return others.some(
       ([other, b]) =>
         b.status === 'closed' &&
-        owns(b.owned_files, file) &&
+        owns(b.owned_files, file, b.owned_kinds) &&
         rows.some((r) => r?.event === 'review.approved' && r.block === other && r.file === file && r.content_hash === hash && verified(r, key)),
     );
   };
@@ -712,7 +713,7 @@ export async function unownedChanges({ top, changed, id, blocks, rows, key, isMi
   const siblings = [];
   for (const file of changed) {
     if (state(file) || isMine(file) || (await unchangedSinceOpen(file))) continue;
-    const sibling = others.find(([, b]) => b.status === 'open' && owns(b.owned_files, file));
+    const sibling = others.find(([, b]) => b.status === 'open' && owns(b.owned_files, file, b.owned_kinds));
     if (sibling) siblings.push({ file, block: sibling[0] });
     else if (!approvedClosed(file)) unowned.push(file);
   }

package/src/session/plan-check.mjs

@@ -29,6 +29,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { assertOwned, findOverlap, ownsFile } from '../state/registry.mjs';
+import { ownedKinds } from '../state/owned-kinds.mjs';
 import { extractClaims, parseSheet, sha256 } from './facts.mjs';
 import { findSection, nearMissWarning, REQUIRED_SECTIONS } from './plan-sections.mjs';
 
@@ -300,6 +301,9 @@ export function recordedLanes(rows, planName) {
  *   `run reload` is then backed by a VERIFIED `<bin> run reload`.
  * @property {Array<Record<string, any>>} [decisions] - the project's ledger rows (the recorded lanes);
  *   none given ⇒ no block has a recorded lane.
+ * @property {string} [root] - B57: the project root the owned paths are relative to; an exact owned
+ *   path that is a regular file there owns only itself in the overlap and seam checks (as at
+ *   `block open`). None given ⇒ every exact owned path is directory-like (fail closed).
  */
 
 /**
@@ -383,12 +387,23 @@ export function checkPlan(text, opts = {}) {
     else if (b.lines > limits.blockLines) errors.push(`block ${b.id}: lines forecast ${b.lines} exceeds budget.block_lines ${limits.blockLines} — split it`);
   }
 
-  // disjoint owned files per wave
+  // disjoint owned files per wave (B57: an exact path owns the paths below it unless it is a file)
+  // (paths are looked at only once they pass `assertOwned`: never `..` or absolute)
+  /** @param {PlanBlock} b @returns {Record<string, string>} */
+  const kindsFor = (b) => {
+    if (opts.root === undefined) return {};
+    try {
+      return ownedKinds(opts.root, assertOwned(b.owned));
+    } catch {
+      return {};
+    }
+  };
+  const kindsOf = new Map(blocks.map((b) => [b.id, kindsFor(b)]));
   for (let i = 0; i < blocks.length; i += 1) {
     for (let j = i + 1; j < blocks.length; j += 1) {
       const [a, b] = [blocks[i], blocks[j]];
       if (a.wave !== b.wave) continue;
-      const hit = findOverlap(a.owned, b.owned);
+      const hit = findOverlap(a.owned, b.owned, { kindsA: kindsOf.get(a.id), kindsB: kindsOf.get(b.id) });
       if (hit) errors.push(`blocks ${a.id} and ${b.id} (wave ${a.wave}) overlap: ${hit[0]} / ${hit[1]}`);
     }
   }
@@ -398,7 +413,7 @@ export function checkPlan(text, opts = {}) {
   for (const b of blocks) {
     const deps = closure(blocks, b.id);
     for (const imported of b.imports) {
-      const owner = blocks.find((o) => o.id !== b.id && ownsFile(o.owned, imported));
+      const owner = blocks.find((o) => o.id !== b.id && ownsFile(o.owned, imported, kindsOf.get(o.id)));
       if (owner && !deps.has(owner.id)) errors.push(`block ${b.id} imports ${imported} owned by ${owner.id}, which is not in its depends_on`);
     }
   }

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

@@ -107,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');
@@ -125,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. */
@@ -210,7 +213,7 @@ 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 });
+  const peerDiffs = blockPeerDiffs(ctx.repoRoot, { base: entry.base, owned: entry.owned, ownedKinds: entry.ownedKinds, file: ticket.file });
   try {
     if (!ctx.key) {
       return await reviewFile(
@@ -218,7 +221,7 @@ export async function reviewTicket(ticket, ctx) {
         { 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), peerDiffs });
+    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 });
   }
@@ -229,13 +232,13 @@ export async function reviewTicket(ticket, ctx) {
  * 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
+ * @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, file }) {
+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));
+    return (await computeFileSet({ cwd: repoRoot, base })).all.filter((f) => f !== file && ownsFile(owned, f, ownedKinds));
   } catch {
     return [];
   }
@@ -246,16 +249,16 @@ export async function blockPeers(repoRoot, { base, owned, file }) {
  * 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
+ * @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, file }) {
+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, file }) })();
+        return await peerDiffReader({ repoRoot, base, file, peers: await blockPeers(repoRoot, { base, owned, ownedKinds, file }) })();
       } catch {
         return [];
       }
@@ -326,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, peerDiffs?: () => Promise<import('../review/moved.mjs').PeerDiff[]>}} 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, peerDiffs }) {
+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>}} */
@@ -343,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);
@@ -489,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