The wrong reasoning is one sentence, and it was written down: coherence
phase 2 said the derived body was "deferred with the instantiation set
(no code-gen consumer yet); the *row* is what TY4c needs." A row with no
body is not a deferral, it is a promise nothing keeps.

The mechanism. `register_derives` allocated an `ImplId` carrying a span
and zero methods, then inserted it at `(Equals, [Pt])`. That is enough
for `T is Equals` to answer Yes in one hash probe, so `p == q` resolved
through TY5, typed `Bool`, and `ckc check` reported the program CLEAN;
monomorphization then found no `FnId` behind that `ImplId`, and
`emit_call_value` fell past user-fn, machine-op, syscall and the tick
grain to its terminal `Err(CodegenError::Unsupported(callee_span))` —
`unsupported Floor IR form`, at the surface an author reaches last.

`plan_traits.md` §3 forbids the cheap repair ("there is no compiler-level
`==`"), so the derive owes a real hand-writable impl. `ck_load::derive`
writes it source-to-source on the §2a actor desugar's precedent, in
`finish` where the whole closure is loaded, and CONSUMES the sugar: the
`Equals` token is cut out of the `composes` clause by byte range (every
other trait keeps its text and its generic arguments) and the page gains

  impl Equals<Pt> {
    fn equals(a: Pt, b: Pt) -> Bool = (a.x == b.x && a.y == b.y)
    fn not_equals(a: Pt, b: Pt) -> Bool = !((a.x == b.x && a.y == b.y))
  }

The conjunction folds LEFT with explicit parentheses because CkLang has
no universal associativity — `a && b && c` is E0146. Two fields hide
that; `todo_effect`'s three-field `Task` and `Dijkstra`'s `Arc` found it.

What moved: `ck_load` only. `ck_types` was NOT touched — with the clause
consumed, phase 2 never sees a derived record, and the generated impl
registers through phase 1 like any hand-written one. Its comment is
rewritten to say why its own reasoning was wrong.

What did NOT move: the derive fires only where the equality it writes
genuinely resolves — a field type reaching a real `impl Equals<…>`, or
another derived record, over a project-global fixpoint with `type`
aliases followed. That is stricter than E0711 on purpose: a `data …
composes Equals` holds a coherence row no `==` can reach (its values
type as the VARIANTS — the still-OPEN `data_sum_…` cell), so E0711
passes the stdlib's `record LogLine { level: LogLevel, … }`, which is in
every app's closure, and a generated body over it would not resolve.
Records out of reach — `snake`'s `Player { body: List<Pos, 256>, … }` —
keep their clause, their bodyless row and today's behaviour byte for
byte. Generic records are refused: one coherence row cannot serve every
instantiation. `data` is untouched, and stays OPEN.

Ledgers. `BROKEN_CELL_COUNT` 43 -> 42; the cell is renamed
`auto_derived_equals_on_a_record` and declares `runs: 42`. `CELL_COUNT`
440 -> 442 for the two cells that make it discriminate:
`auto_derived_equals_discriminates_on_a_field` (fields differ -> 7, so a
body answering `true` blindly cannot pass) and
`auto_derived_equals_not_equals_is_derived_too` (the `!=` glyph, so the
derive owes both of the trait's methods). R11 `ck_load/src` 9243 -> 9863,
a RAISE carried with a written justification in its doc log —
owner-visible, veto = revert; `ck_load/src/desugar` does not move.

Gates. `./scripts/test.sh` ALL GREEN — 4 legs: unit 1364, corpus 106
apps, capability 442 cells, docs 35 expectations, 0 failures. Workspace
`cargo test --workspace --tests`: 1621 passed, 1 failed. `cargo fmt
--all -- --check` 0 diffs; `cargo clippy --workspace --all-targets -D
warnings` 0 errors 0 warnings.

The one red is `r3_no_file_exceeds_loc_cap` —
`ck_driver/src/lib.rs: 1323 lines (cap 862)`. STANDING, not caused here:
the file is byte-identical to HEAD and untouched by this commit, and
plan.md §1 already tracks it as the one open item ("splitting the driver
root — a slice, not a cleanup").

@@ -0,0 +119,4 @@
+        let mut this = Self {
+            aliases: HashMap::new(),
+            explicit: HashSet::new(),
+            candidates: Vec::new(),

@@ -0,0 +66,4 @@
+}
+
+#[test]
+fn a_field_with_no_equals_is_left_alone() {