nx_compare_rank_fleet.nx
buildroot/runtime/nx_compare_rank_fleet.nx
about
nx_compare_rank_fleet.nx -- PROVE THE RANKING ENGINE ON EVERY COMPARE, and publish the estate
portfolio (PR9). Operator 2026-08-18: "prove it on every compare to show that this engine and system
makes logical sense ... drive us to a true width and breadth compare sota and best of breed using
mechanical provable repeatable capabilities."
Whole population, no sampling: every domain in regen.list is visited. Partition (printed, sums):
RANKED -- has a .plan with rung rows: nx_compare_rank ran, its critical path and top rung
are captured, its comparerank- plane is published by the ranker itself.
NO-LADDER -- ranked, but the plan has no ver| rows: the ranker labeled it "ranking by value
alone"; the fix is a data row, and this census NAMES the domain so it is a worklist.
NO-PLAN -- a .matrix but no .plan: a capability census with NO roadmap the engine can drive.
This is the width-and-breadth gap by name: the compare knows what we lack versus the
field but has not declared what to build first. Fix = a plan (rungs + ver ladder).
NO-MATRIX -- listed in regen.list but no matrix: a hub card with nothing measured behind it.
FAILED -- the ranker exited nonzero or printed nothing: the engine itself is the blocker;
the exit code and last line are printed so the team can act.
Then the PORTFOLIO: every RANKED domain's critical-path #1 rung is fed to nx_dr_ocm ONCE MORE across
domains (value = its printed priority as the estate-comparable score, momentum 1, cost = its printed
c), so the estate-wide next-actions are one ordered list, and that list is written to the
portfolio- plane (id=<domain>/<rung>) and its top rows filed into pm intake. Sponsorship already
rode inside each domain's priority; a domain-scoped sponsor row therefore lifts that domain's #1
across the estate, which is exactly what a domain-level verdict means.
usage: nx_compare_rank_fleet [budget_tenths] (runs from nishihost cwd; forks ./nx_compare_rank.elf
or the _build twin, ./nx_dr_ocm_cli.elf, ./nx_store_put.elf, ./nx_pm_intake.elf)
exit: 0 (census printed; the verdict is the partition, not a pass/fail -- a NO-PLAN domain is a
worklist row, not a failure of this organ) | 3 regen.list unreadable
license_tier: ORIGINAL No hw writes (Rule 26).
dependencies 2 imports · 0 importers
imports: nx_syscalls.nxnx_tool_run.nx
imported by: nobody (leaf or entry point)
call flow from main pre-order; caps 40 nodes / depth 6 declared; ↻ = already shown
structs
| none |
consts
| 32 | const RF_MAX_DOM: i64 = 128 |
| 33 | const RF_CAP: i64 = 262144 |
| 34 | const RF_LIST_CAP: i64 = 16384 |
| 35 | const RF_TIMEOUT_MS: i64 = 280000 |
| 36 | const RF_PM_TOP: i64 = 5 // estate-level intake rows per run |
| 37 | const RF_DEFAULT_BUDGET: i64 = 300 |
functions
| 39 | func rf_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n } |
| 40 | func rf_puts(s: *u8) -> i64 { sys_write(1, s, rf_slen(s)); return 0 } |
| 41 | func rf_pn(v: i64) -> i64 |
| 53 | func rf_cat(d: *u8, o: i64, s: *u8) -> i64 { var i: i64 = 0; var oo: i64 = o; while s[i] != (0 as u8) { d[oo] = s[i]; oo = oo + 1; i = i + 1 } d[oo] = 0 as u8; return oo } called by 1: main |
| 54 | func rf_catn(d: *u8, o: i64, v: i64) -> i64 |
| 64 | func rf_read(path: *u8, b: *u8, cap: i64) -> i64 |
| 73 | func rf_exists(path: *u8) -> i64 { let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 } sys_close(fd); return 1 } |
| 74 | func rf_find(hay: *u8, hlen: i64, needle: *u8) -> i64 |
| 85 | func rf_int_after(hay: *u8, hlen: i64, needle: *u8) -> i64 |
| 95 | func rf_tok_after(hay: *u8, hlen: i64, needle: *u8, dst: *u8, dcap: i64) -> i64 |
| 115 | func rf_emit_row_as_decided(dname: *i64, dclass: *i64, dtop: *i64, dstage: *i64, dpri: *i64, dcost: *i64, i2: i64) -> i64 |
| 127 | func main(argc: i64, argv: *i64) -> i64 |