A map of a tangle
is still a tangle.

The measure

Four tiers. Each one is the tier below it plus a single property.

Scored over the graph the canvas actually draws — a folder's immediate children, each subfolder standing as one node. Not every descendant flattened together: that sees more, but it scores a picture nobody looks at, and a reader told “this folder is tangled” has to be able to look at the folder and see the tangle.

1. 0

   Cyclic

   + nothing — this is the floor

   Children depend on each other in a loop. There is no order to read the drawing in, and no other property means anything measured on top of it.

   Break the loop — usually by moving the shared piece down into a child both can depend on.

2. 1

   Tangled

   + acyclicity

   Acyclic, so there is an order — but edges jump levels instead of stepping down one at a time. The drawing has no layers to follow.

   Either the intermediate layer is not carrying the traffic it should, or the shortcuts around it are the real design.

3. 2

   Hierarchical

   + layering

   A clean layered DAG. Readable at this level, and says nothing at all about whether the folders inside it are.

   Readable here. What holds it short of fractal is breadth, merging, the doors, or a folder one level down.

4. 3

   Fractal

   + breadth, branching, doors, and children that hold the same shape

   The shape holds at more than one zoom level. Few enough children to take in at once, branching rather than merging, entered from outside through few doors, and made of children that are themselves at least hierarchical.

   Nothing to do — the shape holds at every level.

Fractal is recursive by construction. Its last clause is a claim about the children, so a folder cannot earn it while sitting on top of a mess — which is what makes the measure self-similarity across zoom levels rather than one level's opinion. It is also what makes the work order fall out for free: a parent held back by a tangled subfolder cannot move until that subfolder does, so the report lists the deepest actionable folder first.

The gates

Seven bars, and only one of them is a convention.

Six are readings of the drawing. The seventh is a count, and it is the one with a story — see below. Own drawing marks the gates a reader can settle by looking at the picture in front of them, as against the ones answered only by the subfolders, the callers, or the blend; that split decides which folder to work on first.

Branching and breadth gate the tier and stay out of compliance deliberately, so a folder can blend well and still be held back by one of them. A blend cannot carry the reason: two folders at 0.72 can need opposite fixes, so the tool names the binding constraint instead — why rather than how much.

Where it comes out

Shape arrives unasked, and in work order.

It is part of the quality report rather than a command you have to know about. The folders short of fractal are split by whether their blocker is in their own drawing, and ranked deepest-first within that — because clearing a deep one can clear a parent's child gate too.

## Folder shape (40 folders)
6 cyclic · 4 tangled · 16 hierarchical · 14 fractal

### Start here *for shape* — the blocker is in the folder's own drawing (10 of 23 shown)
- [hierarchical] parser/dart/declarations — held back by children reaching
  outside from its middle (out-at-the-bottom 0.50); compliance 0.81, acyclic
  1.00, layered 0.71, branching 0.71, one-door-in 0.50, 6 children
- [cyclic] parser/groovy — held back by a loop among its children (acyclic
  0.83); compliance 0.78, acyclic 0.83, layered 0.59, branching 0.59,
  one-door-in 1.00, 12 children
- [tangled] parser/go — held back by edges skipping levels (layered 0.57);
  compliance 0.83, acyclic 1.00, layered 0.57, branching 0.57, one-door-in
  0.75, 9 children
- [hierarchical] parser/rust — held back by more children than a reader holds
  at once (9 of them); compliance 0.90, acyclic 1.00, layered 0.89, branching
  0.89, one-door-in 0.67, 9 children

### Answered elsewhere — blocked on children, callers or the blend (3)
- [hierarchical] parser/typescript/bodies — held back by too many doors in
  (one-door-in 0.40)

Twenty-two of thirty-nine folders hold their shape; five are cyclic. That is the engine's own tree, unedited — a tool that only ever showed clean output on its own code would be worth less, not more.

The tool

One folder's drawing, and one rung to climb.

A line reading “tangled, layered 0.61” names a defect without naming any of the six edges that caused it. reshape hands over the drawing behind the verdict — the children with their levels, every edge with its reading, the doors and the traffic through them — plus an instruction scoped to exactly one rung of the ladder.

## Verdict
**cyclic** — held back by a loop among its children (acyclic 0.20).

- acyclicity 0.20 (must be 1.00 to clear `cyclic`)
- layering 1.00 (needs ≥ 0.70 to clear `tangled`)
- branching 1.00 (needs ≥ 0.70 for `fractal`; NOT part of compliance)
- entry concentration 0.50 (needs ≥ 0.60 for `fractal`) — **2 ways in**,
  which the ratio does not say
- out at the bottom 0.60 (needs ≥ 0.70 for `fractal`; NOT part of
  compliance) — **4 exits from the middle**, which the ratio does not say
- compliance 0.54 (needs ≥ 0.85 for `fractal`)
- 5 immediate children (needs ≤ 8 for `fractal`; NOT part of compliance)

## Your task: cyclic → tangled

Break the loops among these children. 6 of 9 edges run inside one, so the
drawing has no reading order at all — every other property is measured on
top of this one.

**One loop**, 4 children and 6 edges:

- `src/check/mod.rs → src/check/count.rs` — carries 1 entity: `violations`
- `src/check/count.rs → src/check/mod.rs` — carries 2 entities:
  `Violation`, `repo_relative`
- `src/check/report.rs → src/check/mod.rs` — carries 3 entities: `Cited`,
  `Outcome`, `Violation`

Cut the cheapest edge that is genuinely a back edge. An edge carrying one
entity is usually a definition sitting in the wrong file, and moving that
definition into a file both ends can depend on breaks the loop without
touching either caller. An edge carrying twenty is the folder's real
structure, and inverting it is a rewrite that will not survive review.

Stop there. The tiers are a ladder and `tangled` is the next rung — the
gates above it are measured on top of this one and are not worth chasing
until it clears.

In CI

Mezzanine ships no rules of its own.

mezz check grades a tree against rules the project wrote down. Every failure it can produce traces to a line somebody in the checked repo authored, and a repo with no rules file passes and says so.

{
  "rules": {
    "max_entities_per_file": 7,
    "max_elements_per_entity": 7,
    "max_doors_per_folder": 1
  },
  "exempt": ["**/tests.rs"]
}

$ mezz check .          # a fresh clone, no rules file
no rules declared in .mezz/rules.json      # exit 0

$ mezz check .          # after declaring the bars above
src/analyzer/mod.rs:1 — max_entities_per_file: 54 declared, bar is 7
src/analyzer/mod.rs:79 — max_elements_per_entity: Analyzer has 34 elements, bar is 7
src/config.rs:13 — max_elements_per_entity: Config has 16 elements, bar is 7
src/diff.rs:1 — max_entities_per_file: 106 declared, bar is 7

Exit 0 when every declared rule holds or none was declared, 1 when one does not, 2 when no verdict could be computed — a gate that passed because it could not understand its own configuration is the failure the command exists to stop.

A tool may hand you a diagnosis you are free to disagree with; it may not fail your build with one.

ADR 0024 — a-check-fails-on-the-projects-rules-not-mezzs

This is why min_shape: fractal is not a rule anybody can declare, and its absence is a decision rather than an omission. The tiers are Mezzanine's, and three separate decision records have each conceded that its gates can be wrong about a specific folder. Rules are expressed over Mezzanine's measurements — but the threshold is arbitrary, arguable, and the project's to argue over.

What it looks like when it holds

Four rules, and a door in every language.

The ladder measures; it does not tell you how to write. These four rules are what the engine is developed against — held to across seven languages, in seven copies of the same small program, every folder of every one of them scoring fractal. They are language-independent. What changes between them is only which file the convention makes the door.