Beagle SCM

ABC-021: SORTu64 emits garbage — Yx tie loop drains the whole heap

Found by the smoke-fuzz CI lane (2026-07-19, libabc@9131017): SORTfuzz differential vs u64sSort dies in <10k iterations. This is the "merge RESULT is independently broken ... tracked as a separate ticket" note in test/SORT.c (MEM-003 session) — this IS that ticket. Four defects compose; the net effect is the sort emits only the global minimum (rest is stale memory), or NOROOMs. SORTu64 has no production callers yet, so no data paths are affected — but it blocks the smoke-fuzz CI lane.

Input

Context

• CI: ubuntu smoke-fuzz job, assert fail element mismatch at SORTfuzz:24; minimal input 16×0x22+\n = two equal u64 → output {0x2222…, 0}. Reproduced locally (session 2026-07-19, WORK-011 journal).
• Defect 1, Yx.h _X(next): the tie-collection loop guard is 0 == _X(z)($head(lsm), &next) — z is strict less-than and next was just popped off a min-heap, so head >= next always, z(head,next) always false → the loop drains the ENTIRE heap as one "tie group". Args are swapped: the guard must be 0 == _X(z)(&next, $head(lsm)) (tie ⟺ head==next).
• Defect 2, SORT.h SORTu64y: emits only eqs[0] of a tie group (dedup semantics); a sort must emit every tied element. Combined with defect 1, the whole merge emits one element, then *into += $len(from) claims full length → tail is stale memory.
• Defect 3, SORT.c ping-pong: pass N+1 takes the FULL extent of the destination buffer ($mv(from64, into) = whole idle slice) instead of the n elements pass N wrote → NOROOM (or garbage merged) whenever n > 64 and into is bigger than n. The disabled test/SORT.c sizes buffers exactly to dodge this; the fuzz harness (LEN1=1024) cannot.
• Defect 4, Yx.h tie pad: a tie group larger than the Y_MAX_INPUTS=64 in pad is silently truncated (pre-ABC-007 dropped status) or NOROOMs (post-ABC-007 check). Unbounded equal runs are legal sort input; flush the group when the pad fills and let the next round carry the rest (order is stable among equals).
• Fix for all four verified out-of-tree (2026-07-19): CI crash input + n=65 (NOROOM path) + n=110 with a >64 equal run all green; 2M SORTfuzz iterations clean under ASan.
• Repro seeds: n=2 equal; n=65 distinct; n=110 with >64 equal elements (fuzz artifacts in the WORK-011 session scratch).

Goals

• Repro first: revive SORTtest (commented out in test/CMakeLists.txt) with the three seed cases — red on base, green after; drop the "result is broken" caveat.
• All four defects fixed; SORTfuzz 10k smoke green; full ctest green.

Constraints

• Yx.h is a shared template; SORT.h is its only instantiation today. Flush-on-full splits tie groups — fine for a sort; a future dedup-style y gets the same key in two calls, so note the contract at the flush site.
• MEM-003's at-creation chunk clamp must survive the SORT.c rework; keep the ABC-007 FeedP status check.
• Comment budget 4 lines, mention the ticket.

WIP

Design decisions

• Fix shape agreed + verified before ticketing (see Context); re-applied on the current tip in work/ABC-021.
• SORT.c rework: explicit n-element src/dst views per pass (n = $len(from)), no $mv of caller slices; final dir==NO copy checks the Feed status.

TODOs

• wt in work/ABC-021, patches re-applied on tip 3e047885
• SORTtest revived, 10 result-checked cases (incl. the 3 seeds), red on base → green after
• SORTfuzz 10k smoke + 500k extended clean; ctest 49/49
• human gate, then land

Blockers and bummers

• (none)

Outcome

• (open)