@codedology/code-forge 0.7.4 → 0.7.6

package/CHANGELOG.md

@@ -6,6 +6,36 @@ waits on a second real consumer (plan §10.4, Q17).
 
 ## [Unreleased]
 
+## [0.7.6] — 2026-10-11
+
+### Added
+
+- review.external {required, name} (B58, issue #11): an owner-approved outside reviewer replaces the local per-file
+  review. Read only from the run-start config snapshot (run reload refuses to change it; run start refuses required:
+  true without a name) and signed as a review.external row; block close then skips the per-file review check (also
+  not_approved) and writes a signed gate.reviews_waived {by: config, reviewer} row just before block.close, only when
+  the block closes, with no TTY and under autopilot. Unowned, proof, no_changes, transcript, orphans and closeBlock
+  checks still refuse. block open and block claim refuse an owned entry that covers .code-forge.yml. Without the key
+  nothing changes.
+
+### Changed
+
+- block open, block claim and block close now read the run's config snapshot; a snapshot that does not match its hash
+  refuses them with config-snapshot, with or without review.external (B58).
+
+## [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,22 @@ for cross-model, parallel, evidence-gated feature delivery — on Claude Code, C
 
 Next release:
 
+- **An outside reviewer can replace the local review.** Set `review.external: {required: true,
+  name: <reviewer>}` in `.code-forge.yml`. `block close` then skips the per-file review check
+  and writes a signed `gate.reviews_waived` row with `by: config`. It needs no TTY and works
+  under autopilot. All other close checks still run. The key is fixed at `run start`, and a
+  coder can never own `.code-forge.yml`.
+
+In 0.7.5:
+
+- **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": 61,
   "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,32 @@
         "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"
+    },
+    "B58": {
+      "title": "Outside reviewer (issue #11, #13 item 1): config key review.external {required, name}, read only from the run-start config snapshot (immutable, run reload refuses it), signed review.external row at run start; block close skips the per-file review check and writes a signed gate.reviews_waived {by: config, reviewer} row just before block.close, only when the block closes; unowned, proof, no_changes, transcript and closeBlock checks still refuse; block open and block claim refuse an owned entry that covers .code-forge.yml; run start refuses required: true without a name",
+      "wave": 13,
+      "level": "L2",
+      "status": "landed",
+      "owned": [
+        "test/review/external.test.mjs"
+      ],
+      "depends_on": [
+        "B57"
+      ],
+      "note": "root-added 2026-10-11; GitHub issue #13 adoption plan (plans/adoption-13/plan.md); also amends src/state/{config-snapshot,run,block}.mjs, src/cli/block.mjs, schema/code-forge.schema.json, docs/reference/config.md, docs/{how-it-works,concepts}.md, skill/references/{review,decisions,code}.md, test/config/schema-coverage.test.mjs"
     }
   }
 }

package/docs/reference/config.md

@@ -117,6 +117,9 @@ Every other key defaults as shown, or is entirely absent from a minimal file. `a
 | `review.provider_concurrency.openai` | integer |  | `2` | min 1 |
 | `review.provider_concurrency.xai` | integer |  | `2` | min 1 |
 | `review.parallel_tickets` | integer |  | `3` | min 1; max 16; B42: how many review tickets the worker runs at once (oldest first); 1 = one at a time. Tickets for the same file never overlap. |
+| `review.external` | object |  | — |  |
+| `review.external.required` | boolean |  | `false` | B58: true ⇒ block close skips the local per-file review checks (and the --report ticket check), with no terminal and under autopilot, and writes a signed gate.reviews_waived {by: config} row. Unowned changes, proof, no_changes and the transcript grep still refuse. No block may own .code-forge.yml. |
+| `review.external.name` | string |  | — | minLength 1; B58: the outside reviewer, written in the review.external and gate.reviews_waived rows. Required when required is true: run start refuses a missing or blank name. |
 | `engine` | enum: `auto`, `solo`, `harness`, `subprocess` |  | `"auto"` |  |
 | `harnesses` | array<string> |  | — |  |
 | `harness` | object |  | — |  |

package/package.json

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

package/schema/code-forge.schema.json

@@ -153,7 +153,16 @@
             "xai": { "type": "integer", "minimum": 1, "default": 2 }
           }
         },
-        "parallel_tickets": { "type": "integer", "minimum": 1, "maximum": 16, "default": 3, "description": "B42: how many review tickets the worker runs at once (oldest first); 1 = one at a time. Tickets for the same file never overlap." }
+        "parallel_tickets": { "type": "integer", "minimum": 1, "maximum": 16, "default": 3, "description": "B42: how many review tickets the worker runs at once (oldest first); 1 = one at a time. Tickets for the same file never overlap." },
+        "external": {
+          "type": "object",
+          "additionalProperties": false,
+          "description": "B58: an outside reviewer reviews each block. Set it before run start; run reload refuses to add, remove or change it.",
+          "properties": {
+            "required": { "type": "boolean", "default": false, "description": "B58: true ⇒ block close skips the local per-file review checks (and the --report ticket check), with no terminal and under autopilot, and writes a signed gate.reviews_waived {by: config} row. Unowned changes, proof, no_changes and the transcript grep still refuse. No block may own .code-forge.yml." },
+            "name": { "type": "string", "minLength": 1, "pattern": "\\S", "description": "B58: the outside reviewer, written in the review.external and gate.reviews_waived rows. Required when required is true: run start refuses a missing or blank name." }
+          }
+        }
       }
     },
     "engine": { "type": "string", "enum": ["auto", "solo", "harness", "subprocess"], "default": "auto" },

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.
@@ -41,7 +41,7 @@ The coder's report is a claim sheet. The gate reproduces each number in the meas
 | rows genuine | the MAC of every gate-relevant row verifies; the live worker matches the pinned pid |
 | nothing left open | no unruled `late_findings` (a ruling clears only a warning or nit ruled `nit`; a critical late finding needs the human's waiver); no file at `review_cap` without a signed `review.waived` row |
 
-`--no-require-reviews` is the human's way out, written as its own audit row. The human runs it themselves at a terminal: it asks for a yes, has no `--yes`, exits 2 unless stdin and stdout are both terminals, lifts `no_changes` and is refused while an autopilot grant is active — so never run it for them; tell them the command when they say so in chat. A finding counts only under the gate's own configuration; a tautology (an expected value computed by the code under test) is a finding. Reproduce disclosures: a coder that reports its own rule break did the hard part.
+`--no-require-reviews` is the human's way out, written as its own audit row. The human runs it themselves at a terminal: it asks for a yes, has no `--yes`, exits 2 unless stdin and stdout are both terminals, lifts `no_changes` and is refused while an autopilot grant is active — so never run it for them; tell them the command when they say so in chat. The owner's other way out is `review.external` in the config before `run start` (`review.md` §1): the gate then skips the review rows and the report's ticket ids and writes `gate.reviews_waived {by: config}`; every other check, `no_changes` included, still applies. A finding counts only under the gate's own configuration; a tautology (an expected value computed by the code under test) is a finding. Reproduce disclosures: a coder that reports its own rule break did the hard part.
 
 ## §6 Budget — the stop is the feature (R6)
 

package/skill/references/decisions.md

@@ -50,6 +50,6 @@ A fresh L3 session receives the failure evidence — the last attempt's diff, th
 
 ## §7 What reaches the human
 
-`next = stop`, `review.over_budget`, an orphan file or `unowned_change`, a `not_approved` critical finding, `--no-require-reviews`, `worker_down`, `review_cap`, `redecompose`, `ask_human`, a security question, consensus unavailable, and one budget raise per run. Everything else is decided by S1, S2 or the rules above and recorded. A change to a rule, limit or check is never decided here: it always reaches the owner (`rules-core.md` R17).
+`next = stop`, `review.over_budget`, an orphan file or `unowned_change`, a `not_approved` critical finding, `--no-require-reviews`, `worker_down`, `review_cap`, `redecompose`, `ask_human`, a security question, consensus unavailable, and one budget raise per run. The owner has two ways out of the per-file review gate: `--no-require-reviews` at a terminal, or `review.external.required: true` with the outside reviewer's `name`, set in `.code-forge.yml` before `run start` (`review.md` §1). You never choose either one. Everything else is decided by S1, S2 or the rules above and recorded. A change to a rule, limit or check is never decided here: it always reaches the owner (`rules-core.md` R17).
 
 **Autopilot:** while a grant is active, a warning or nit waiver, one extra round at `review_cap` and a coder level go first to the delegate (`forge autopilot ask`, then `forge autopilot waive|round|level --decision <id>` only when it acted, `autopilot.md` §2). Never delegated: `next = stop`, `ask_human`, a security question, a critical finding, a budget raise, `redecompose` — they wait for the owner (`autopilot.md` §5).

package/skill/references/review.md

@@ -4,6 +4,8 @@
 
 `forge review-file <path> --block <id> --run <r>` enqueues a ticket and returns `{ticket, status: queued}` in under a second; `forge review-file --wait <ticket> [--max 90s]` polls it. The worker computes the diff itself against the base sha `forge block open` recorded: tracked changes plus untracked files, filtered by `owned_files` for the review and unfiltered for the scope check. A coder that never calls `review-file` gains nothing: the block gate refuses any changed or new file without a signed `review.approved` row for its final content hash. The reviewer is always a new OS process (R1, R10) — identical under Solo, a harness subagent, a detached CLI process, or a human typing.
 
+**The owner's two ways out of the per-file review.** (1) `forge block close <id> --no-require-reviews`, typed by the owner at a terminal (`code.md` §5). (2) `review.external: {required: true, name: <reviewer>}` in `.code-forge.yml`, set before `run start`, when an outside reviewer reviews each block (B58). With `required: true`, `run start` refuses a missing or blank `name`, and writes a signed `review.external` row with the reviewer's name. `run reload` refuses to add, remove or change the key. With the key, `block close` does not check the review rows (a `not_approved` file included) or the report's ticket ids, needs no terminal and works under an autopilot grant. When the block closes, it writes a signed `gate.reviews_waived {by: config, reviewer}` row just before `block.close`; a refused close writes no such row. Unowned changes, `unproven`, `no_changes`, the transcript grep and the registry's orphans still refuse. No block may own `.code-forge.yml` while the key is on: `block open` and `block claim` refuse it. `block open`, `block claim` and `block close` read the run's config snapshot to find the key, so a snapshot that does not match its hash refuses them with `config-snapshot`, with or without the key. Never set or remove the key yourself: it is the owner's decision.
+
 ## §2 Depth by risk (adaptive mode)
 
 The topology is decided in one place (`planSessions`). Consensus (§6) runs only when `review.multimodel` is on **and** the file's risk is above `review.single_reviewer_max_risk` (default 1) **and** the block is not a `docs`/`contract` block (`decisions.md` §5) unless `review.multimodel_for_docs` is true (default false). Everything else is adaptive, below. Why: a consensus review of a four-file docs block cost $16.70 — review cost dominates, and a low-risk file gains nothing from a second provider.

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.6"
 set -eu
 
 self="$0"

package/src/cli/block.mjs

@@ -50,6 +50,15 @@
  * FAILED: no review-file ticket id for <files>` (skipped under `--no-require-reviews`, the human's
  * way out). It runs after the review rows and reuses their file set (listed once).
  *
+ * B58 (issue #11): `review.external.required: true` in the run's config snapshot (the owner set it
+ * before `run start`; `run reload` refuses to change it) is the owner's non-interactive way out
+ * when an outside reviewer reviews the block: the per-file review checks and the `--report` ticket
+ * check are skipped, with no TTY and under an active autopilot grant, and a signed
+ * `gate.reviews_waived {by: config, reviewer: <name>}` row is written just before `block.close`,
+ * only when the block closes. Everything
+ * else still refuses — `unowned_change`, `unproven`, `no_changes`, the transcript grep and
+ * `closeBlock`'s own rows. With `--no-require-reviews` the human path runs exactly as without the key.
+ *
  * B47: `block open` without `--level` takes the level `autopilot level` chose for the block (the
  * latest `autopilot.level` row of the run for it whose MAC verifies, `autopilotLevel`); with
  * neither it is a usage error (`no --level given and no autopilot level recorded for <id>`). An
@@ -67,6 +76,7 @@ import { approvalCheckText, expiryChecks } from '../autopilot/limits.mjs';
 import { appendRow, readAllRows } from '../ledger/write.mjs';
 import { attemptBlock, claimPath, closeBlock, openBlock, rebaseBlock, repoTop, stopBlock } from '../state/block.mjs';
 import { intFlag, parseFlags } from '../state/cli-args.mjs';
+import { externalReviewer } from '../state/config-snapshot.mjs';
 import { StateError } from '../state/paths.mjs';
 import { readRun, writeSigned } from '../state/run.mjs';
 import { loadKey, verifyRow } from '../state/signer.mjs';
@@ -201,6 +211,9 @@ export async function runBlock(args, deps = {}) {
           return 1;
         }
       }
+      // B58: the owner's other way out — `review.external.required` in the run's config snapshot
+      // (set before `run start`, immutable): no TTY, allowed under autopilot, the human flag wins
+      const external = reviewsWaived ? null : externalReviewer(record);
       const rows = (await readAllRows(record.project)).filter((row) => row.run === runId);
       // B52: ONE path base and ONE listing, memoised as a promise and shared by every check. The
       // base is the repository top level: the worker signs every review row with a repo-root-
@@ -218,7 +231,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 +251,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)) {
@@ -265,8 +278,9 @@ export async function runBlock(args, deps = {}) {
           unowned: scope?.unowned ?? [],
           // B52: an old ledger's review.result rows are judged by their signed result files
           resultFiles: await resultFilesFor({ repoRoot: top, runId, block: id, rows }),
-          files: reviewsWaived ? [] : fileSet,
-          // B52: nothing changed and nothing reviewed is never a pass (the owner's way out is --no-require-reviews)
+          files: reviewsWaived || external !== null ? [] : fileSet,
+          // B52: nothing changed and nothing reviewed is never a pass (the owner's way out is
+          // --no-require-reviews); B58: `review.external` does not lift it
           noChanges: !reviewsWaived && fileSet.length === 0,
           // B20: high-tier files need a proven red→green row; `--no-require-reviews` does not lift it
           proofFiles: fileSet,
@@ -275,7 +289,7 @@ export async function runBlock(args, deps = {}) {
       });
       // B36: the coder's report names a review-file ticket for every changed file, or it is FAILED
       const report = async () => {
-        if (typeof flags.report !== 'string' || reviewsWaived) return { ok: true };
+        if (typeof flags.report !== 'string' || reviewsWaived || external !== null) return { ok: true };
         let text;
         try {
           text = await readFile(flags.report, 'utf8');
@@ -286,7 +300,10 @@ export async function runBlock(args, deps = {}) {
         const missing = missingReviewTickets(text, fileSet.map((f) => f.file));
         return missing.length === 0 ? { ok: true } : { ok: false, reason: `coder report FAILED: no review-file ticket id for ${missing.join(', ')}` };
       };
-      const result = await closeBlock({ runId, id, rows, writeRow, livePid: intFlag(flags['worker-pid'], 'worker-pid'), probe, extraChecks: [reviews, report] });
+      // B58: the config waiver row is written by `closeBlock` under the run lock, just before
+      // `block.close` and only when every other check passed — never by a refused close
+      const closeRows = external === null ? [] : [{ event: 'gate.reviews_waived', block: id, by: 'config', reviewer: external }];
+      const result = await closeBlock({ runId, id, rows, writeRow, livePid: intFlag(flags['worker-pid'], 'worker-pid'), probe, extraChecks: [reviews, report], closeRows });
       (result.ok ? out : err)(`block ${id} ${result.status}${result.event ? ` (${result.event})` : ''}${result.reason ? `: ${result.reason}` : ''}\n`);
       return result.ok ? 0 : 1;
     }

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,12 @@ 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 { DEFAULT_CONFIG_FILENAME } from '../config/load.mjs';
+import { externalReviewer } from './config-snapshot.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';
 
@@ -253,6 +256,39 @@ function activeBlocks(record) {
   return Object.fromEntries(Object.entries(record.blocks).filter(([, b]) => b.status === 'open'));
 }
 
+/**
+ * B58: with `review.external.required` set in the run's snapshot, the project's `.code-forge.yml`
+ * is the owner's switch past the local per-file review, so no block may own it. These are the
+ * spellings an owned entry may match it by: relative to the workspace and, for a workspace in a
+ * subdirectory, relative to the repository top level (the close gate matches both, `ownsAt`).
+ * Empty when the key is not set.
+ * @param {Record<string, any>} record @returns {Promise<string[]>}
+ * @throws {StateError} `config-snapshot`, `git-failed`
+ */
+async function guardedConfigPaths(record) {
+  if (externalReviewer(record) === null) return [];
+  const top = await repoTop(record.workspace);
+  // the repo-top spelling `<prefix>/.code-forge.yml` may also match a different file of the same
+  // name under the workspace (`<ws>/<prefix>/.code-forge.yml`): that over-match only refuses more,
+  // never less, and is the one `ownsAt` gives the close gate
+  const prefix = path.relative(top, realpathSync(record.workspace)).split(path.sep).join('/');
+  return prefix === '' ? [DEFAULT_CONFIG_FILENAME] : [DEFAULT_CONFIG_FILENAME, `${prefix}/${DEFAULT_CONFIG_FILENAME}`];
+}
+
+/**
+ * B58: refuse an owned entry that owns one of `guarded` (B57's rule, `ownsFile`: the exact path,
+ * a directory above it, or a glob that matches it).
+ * @param {ReadonlyArray<string>} owned @param {import('./registry.mjs').OwnedKinds} kinds @param {ReadonlyArray<string>} guarded
+ * @throws {StateError} `config-owned`
+ */
+function refuseConfigOwner(owned, kinds, guarded) {
+  for (const entry of owned) {
+    if (guarded.some((file) => ownsFile([entry], file, kinds))) {
+      throw new StateError('config-owned', `owned entry ${JSON.stringify(entry)} covers the project's ${DEFAULT_CONFIG_FILENAME}; no block may own it while review.external.required is true`);
+    }
+  }
+}
+
 /**
  * `block open` — refuses a second open of the same id and any owned set that overlaps another
  * ACTIVE block's; records base, owned files, level, attempt, acceptance, line forecast and the
@@ -261,6 +297,8 @@ function activeBlocks(record) {
  * and the dispatch row carry the floor level, and the row adds `requested_level` and
  * `trigger: 'docs_floor'`. B52: the entry also records `tree_at_open` ({@link treeAtOpen}), the
  * tree's changes at open, which `block close` reads to tell the coder's changes from earlier ones.
+ * B58: with `review.external.required` set, an owned entry that owns the project's config is
+ * refused (`config-owned`, {@link refuseConfigOwner}).
  * @param {{
  *   runId: string, id: string, level: string, owned: string[], acceptance: unknown,
  *   attempt?: number, base?: string, lines?: number, brief?: {path: string, content: Buffer | string},
@@ -283,19 +321,26 @@ export async function openBlock(opts) {
 
   // B52: the tree is stamped BEFORE the run lock (hashing can be slow; other block commands must
   // not wait on it); under the lock the base is resolved again and must be the one stamped against
-  const { workspace } = await readRun(runId);
+  const before = await readRun(runId);
+  const { workspace } = before;
   const stampedBase = await resolveCommit(opts.base ?? 'HEAD', workspace);
   const treeOpen = await treeAtOpen(workspace, stampedBase);
+  // B58: `review.external` cannot change mid-run, so the record read here decides
+  const guarded = await guardedConfigPaths(before);
 
   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);
+    refuseConfigOwner(owned, kinds, guarded);
     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 +363,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 +375,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 +385,29 @@ 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`).
+ * B58: with `review.external.required` set, a path that owns the project's config is refused
+ * (`config-owned`), 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)})`);
+  const guarded = await guardedConfigPaths(await readRun(runId));
   await mutateRun(runId, id, writeRow, (record, block) => {
+    const kinds = { [file]: pathKind(record.workspace, file) };
+    refuseConfigOwner([file], kinds, guarded);
     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);
+      block.owned_kinds = { ...block.owned_kinds, ...kinds };
     }
-    if (!block.owned_files.includes(file)) block.owned_files.push(file);
-    record.orphans = record.orphans.filter((/** @type {string} */ o) => o !== file);
+    record.orphans = record.orphans.filter((/** @type {string} */ o) => !ownsFile([file], o, kinds));
     return { result: undefined, rows: [{ event: 'block.claim', block: id, path: file }] };
   });
 }
@@ -384,15 +441,18 @@ export async function stopBlock({ runId, id, reason, writeRow, event = 'block.st
  * stopped); the block's signed `dispatch` row must exist and verify, and every other
  * gate-relevant row of the block must verify ⇒ else `ledger.tamper` (block stopped); then
  * `extraChecks`; finally, UNDER the run lock, orphans in the registry ⇒ refused (block stays
- * open), else closed.
+ * open), else closed. B58: `closeRows` are signed and written under that same lock just before
+ * `block.close`, and only when the block closes — a row that records why it may close is never
+ * left behind by a refused close.
  * @param {{
  *   runId: string, id: string, rows: Record<string, any>[], writeRow: WriteRow,
  *   livePid?: number, probe?: import('./run.mjs').StartTimeProbe,
  *   extraChecks?: Array<() => Promise<{ok: boolean, reason?: string}>>,
+ *   closeRows?: Record<string, any>[],
  * }} opts
  * @returns {Promise<{ok: boolean, status: 'closed' | 'stopped' | 'open', reason?: string, event?: string}>}
  */
-export async function closeBlock({ runId, id, rows, writeRow, livePid, probe, extraChecks = [] }) {
+export async function closeBlock({ runId, id, rows, writeRow, livePid, probe, extraChecks = [], closeRows = [] }) {
   const record = await readRun(runId);
   if (record.blocks[id]?.status !== 'open') throw new StateError('no-block', `block ${id} is not open in run ${runId}`);
 
@@ -430,6 +490,6 @@ export async function closeBlock({ runId, id, rows, writeRow, livePid, probe, ex
     block.status = 'closed';
     /** @type {CloseResult} */
     const closed = { ok: true, status: 'closed' };
-    return { result: closed, rows: [{ event: 'block.close', block: id, status: 'complete' }] };
+    return { result: closed, rows: [...closeRows, { event: 'block.close', block: id, status: 'complete' }] };
   });
 }

package/src/state/config-snapshot.mjs

@@ -18,6 +18,7 @@
  */
 
 import { createHash } from 'node:crypto';
+import { StateError } from './paths.mjs';
 
 /**
  * Keys that cannot change mid-run, each with why. A change to one is refused by `run reload`
@@ -30,6 +31,9 @@ export const IMMUTABLE_KEYS = Object.freeze({
   'tmp.root': "the worker's run temp root is created at run start",
   keys: 'the worker resolves keys once, at start',
   'system1.key': 'the worker resolves the Jev key once, at start',
+  // B58: the owner's switch past the local per-file review is set before the run starts or not at
+  // all, so nobody turns it on (or off) mid-run
+  'review.external': 'the outside reviewer is fixed by the owner before the run starts',
 });
 
 /** @param {unknown} v @returns {boolean} what `JSON.stringify` drops from an object. */
@@ -148,3 +152,26 @@ export function snapshotFor(record, ticket) {
   if (!isMapping(config) || configHash(config) !== hash) throw new Error('config-snapshot');
   return { hash, config };
 }
+
+/**
+ * B58: the outside reviewer named by the snapshot in force when `review.external.required` is
+ * true; null otherwise (key absent, `required` false, or a record from before snapshots). The key
+ * is immutable ({@link IMMUTABLE_KEYS}), so this is the value `run start` stored.
+ * @param {Record<string, any>} record
+ * @returns {string | null}
+ * @throws {StateError} `config-snapshot` when the snapshot in force does not match its hash.
+ */
+export function externalReviewer(record) {
+  let snap;
+  try {
+    snap = snapshotFor(record, '');
+  } catch (thrown) {
+    if (!(thrown instanceof Error) || thrown.message !== 'config-snapshot') throw thrown;
+    throw new StateError('config-snapshot', `run ${record.run_id}: the config snapshot in force does not match its hash`);
+  }
+  const external = snap?.config.review?.external;
+  if (!isMapping(external) || external.required !== true) return null;
+  // required without a usable name is no switch at all (the schema refuses it; this is the floor)
+  const name = typeof external.name === 'string' ? external.name.trim() : '';
+  return name === '' ? null : name; // trimmed: no row ever carries padding
+}

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/state/run.mjs

@@ -16,7 +16,7 @@ import { mkdir, readFile, rename, rmdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { exec } from '../util/exec.mjs';
 import { StateError, assertRunId, assertWorkspaceOutsideRuns, mirrorPath, newRunId, runRecordPath, runsDir } from './paths.mjs';
-import { changedKeyPaths, configHash, IMMUTABLE_KEYS, immutableChanges, initialConfigState } from './config-snapshot.mjs';
+import { changedKeyPaths, configHash, externalReviewer, IMMUTABLE_KEYS, immutableChanges, initialConfigState } from './config-snapshot.mjs';
 import { generateKey, loadKey, signRow } from './signer.mjs';
 
 /** @typedef {(row: Record<string, any>) => Promise<unknown>} WriteRow */
@@ -149,6 +149,12 @@ export async function startRun(opts) {
     throw new StateError('bad-project', 'project slug must match /^[a-z0-9][a-z0-9-]*$/ (config key project.slug)');
   }
   const workspace = assertWorkspaceOutsideRuns(opts.workspace);
+  // B58: the schema lets `review.external` stand without a name while `required` is off; on, the
+  // reviewer must be named — refused before anything is written
+  const external = config.review?.external;
+  if (external?.required === true && (typeof external.name !== 'string' || external.name.trim() === '')) {
+    throw new StateError('external-no-name', 'review.external.required is true but review.external.name is missing or blank');
+  }
   const worker = await pinWorker(opts.workerPid, probe);
   const record = {
     version: 1,
@@ -179,6 +185,9 @@ export async function startRun(opts) {
     await generateKey(runId);
     await saveRun(record);
     await writeSigned(runId, writeRow, { event: 'run.start', engine: record.engine, worker_pinned: worker !== null });
+    // B58: the owner's outside reviewer is on the ledger from the first row of the run on
+    const reviewer = externalReviewer(record);
+    if (reviewer !== null) await writeSigned(runId, writeRow, { event: 'review.external', required: true, reviewer });
     return record;
   });
 }
@@ -198,8 +207,8 @@ export async function startRun(opts) {
  * Fixed keys ({@link IMMUTABLE_KEYS}): every one that changed is refused at once
  * (`immutable-key`, nothing written). A record from before snapshots (no `config`) is checked
  * against what it does store: `engine` and the ledger slug (`effectiveSlug`, computed by the
- * caller the same way `run start` did); it then gets its first snapshot, `changed_keys: null`,
- * `old_hash: null`.
+ * caller the same way `run start` did), and B58's `review.external.required` must not turn true;
+ * it then gets its first snapshot, `changed_keys: null`, `old_hash: null`.
  *
  * No change (same hash) ⇒ nothing written, no row. Otherwise the record is saved FIRST (it is the
  * source of truth), then one signed `run.reload` row: the changed key PATHS (never values) and
@@ -238,6 +247,9 @@ export async function reloadRun({ runId, config, readPending = () => [], effecti
       frozen = [];
       if (effectiveSlug !== undefined && effectiveSlug !== current.project) frozen.push('project.slug');
       if (typeof current.engine === 'string' && (config.engine ?? 'auto') !== current.engine) frozen.push('engine');
+      // B58: a run started without the key has none to keep — turning it on now is a change; an
+      // entry that leaves it off (`required` false or absent, as the schema default) is not
+      if (config.review?.external?.required === true) frozen.push('review.external');
     }
     if (frozen.length > 0) {
       const why = frozen.map((key) => `${key} cannot change mid-run (${IMMUTABLE_KEYS[/** @type {keyof typeof IMMUTABLE_KEYS} */ (key)]})`);

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