nx_frontier_scan.nx source

1// nx_frontier_scan.nx -- THE AUTONOMOUS FRONTIER-NOTICER for a /compare domain. 2// Operator 2026-08-20: "we want to be able to notice things like the metahuman gap without needing claude 3// by having our own research on /compare sota and best of breed and workflowed and mcp and api etc". 4// 5// WHAT THE METAHUMAN GAP ACTUALLY WAS (mined from the transcripts, not assumed -- writer session 6// 55724797-9f7b-4f68-81aa-fd2de7997175, 2026-08-18 18:15:25Z): the operator said the characters looked 7// wrong, a seat ran FIVE WebSearch calls, and appended four citations to charsim.refs whose URLs IT NEVER 8// OPENED (three carry mirror '-' pin '-'; the fourth points at a page fetched three days earlier from a 9// DIFFERENT url). The gap therefore had TWO halves and only ONE of them needed the outside: 10// (A) the INTERNAL deficit signal -- rivals coded Best on skin/hair rows where our symbol is _ABSENT_. 11// Already mechanical, already in our own data, and NOBODY HAD EVER COMPUTED IT. 12// (B) the OUTSIDE BAR -- the 2026 numbers. That genuinely needed the live web. 13// This organ computes (A) from the domain's own files and pulls (B) through the sovereign fetcher. 14// 15// IT EMITS PROPOSALS AND NEVER ADMITS ONE. It does not write <domain>.matrix, <domain>.refs, or any watch 16// cell. The measured law it obeys: no margin threshold makes auto-declaration safe (nx_memsugg, precision 17// 808->890 permil at 24 percent coverage), and A COMPLETION SIGNAL THAT KEYS ON A NAME REWARDS WRITING THE 18// NAME. The list is the answer; a seat adjudicates it. 19// 20// SEEDS ARE DATA, NEVER HAND-TYPED. They come from the domain's own board: 21// <domain>.axes field 4 is literally "frontier-kw;frontier-kw" -- the estate ALREADY declares per-row 22// frontier keywords and nothing had ever consumed them. 23// <domain>.matrix field 1 (the row label) -- always, so a domain without .axes still has seeds. 24// SOURCES ARE DATA TOO: knowledge/frontier_sources.conf. Both endpoints shipped with it were PROVEN 25// reachable through nx_research_fetch before a line of this was written (arXiv API 200/12267 B, HN Algolia 26// 200/17063 B) -- necessary because nx_websearch is OUR OWN CRAWL INDEX (0 results for "metahuman"), so 27// it structurally cannot see the outside. 28// 29// VERBS 30// seeds <domain> -- what this domain is about, from its own data. No network. 31// deficit <domain> -- the internal signal, ranked, WITH THE REASON PER ROW. No network. 32// scan <domain> [maxrows] [maxitems] -- fetch + diff + print proposals. Network. Writes nothing. 33// propose <domain> [maxrows] [maxitems] -- scan, then file the worklist + the frontierprop- plane rows. 34// 35// RESOURCE ENVELOPE (a shipping criterion, not an afterthought): outbound requests are exactly 36// rows_scanned x sources, both bounded by conf and echoed in every run line; buffers are sized FROM THE 37// INPUT (sys_read_file, matrix+refs bytes, source count) so there is no ceiling to guess; the only writes 38// are one worklist file and at most rows x sources x 2 plane upserts, keyed by url hash so a re-scan 39// UPSERTS rather than grows. 40// 41// EXIT: 0 = ran (PROPOSALS may be zero -- that is a RESULT, not a failure) | 1 = REFUSED (named reason) 42// 2 = usage | 3 = domain unreadable 43// 100% sovereign. No hardware writes (Rule 26). license_tier: ORIGINAL expect_exit: 0 44import "nx_syscalls.nx" 45import "nx_deploy_lib.nx" 46// THE ONE RESOLVER FOR A /compare DATA FILE THAT LIVES IN TWO TREES (adopted 2026-09-01). 47// WHY: this organ built its compare paths with a hardcoded "buildroot/knowledge/compare/", and .axes 48// is an AUTHORED file class that lives in the BARE knowledge/ tree. So `seeds` printed 49// "SEED-SOURCE axes ABSENT" for EVERY domain and silently fell back to matrix row LABELS -- which means 50// the per-row `frontier-kw;frontier-kw` field the estate deliberately declares, in 49 .axes files, has 51// never once been used by the frontier noticer it was written for. 52// MEASURED 2026-09-01: buildroot/knowledge/compare/search.axes is ABSENT, knowledge/compare/search.axes 53// is 2533 B. The visible cost: the label "Warm index across index updates" seeded arXiv as 54// warm AND index AND across and returned a paper on tidally locked exoplanets. 55// COMPOSED, NOT HAND-ROLLED: nx_comparetree_lib is the estate's incumbent for exactly this, and the 56// comparetree_adoption ratchet measures 75 offenders against 2 adopters and RISING. Patching a second 57// hardcoded path here would have made this organ offender 76 in the same edit that fixed its symptom. 58import "nx_comparetree_lib.nx" 59// ATTEST (2026-09-06): the bar ruler's month arithmetic and its plan-row readers are COMPOSED, never re-implemented -- 60// one parser for sotabar| rows and one YYYY-MM reader, so this organ and nx_barfresh cannot disagree about a month. 61import "nx_barfresh_lib.nx" 62 63const FS_PIPE: i64 = 124 64const FS_NL: i64 = 10 65const FS_HASH: i64 = 35 66const FS_AT: i64 = 64 67const FS_SEMI: i64 = 59 68const FS_SPACE: i64 = 32 69const FS_PLUS: i64 = 43 70const FS_ZERO: i64 = 48 71const FS_NINE: i64 = 57 72const FS_UPA: i64 = 65 73const FS_UPZ: i64 = 90 74const FS_LOA: i64 = 97 75const FS_LOZ: i64 = 122 76const FS_USCORE: i64 = 95 77const FS_SLASH: i64 = 47 78const FS_COLON: i64 = 58 79const FS_LBRACE: i64 = 123 80// A SECTION TAG is the short word before a colon at the head of a board label -- CREATOR, SKIN, BODY, 81// ANIM, SIM, WORLD, PLATFORM, MESH, HAIR on charsim alone. It names a group, never the subject, so it 82// poisons a query. 16 bytes clears the longest of those with headroom and is short enough that it can 83// never swallow a sentence that merely happens to contain a colon later on. 84const FS_SECTION_MAX: i64 = 16 85const FS_PATHCAP: i64 = 1024 86const FS_URLCAP: i64 = 2048 87const FS_TXTCAP: i64 = 4096 88const FS_MAXP: i64 = 12 89const FS_MAXROWS: i64 = 64 90const FS_RIVALS: i64 = 4 91const FS_CODE_BEST: i64 = 2 92const FS_CODE_YES: i64 = 1 93const FS_HASH_BASE: i64 = 131 94const FS_HASH_MASK: i64 = 0xffffffff 95const FS_HEXDIG: i64 = 8 96const FS_HEXSHIFT: i64 = 4 97const FS_HEXRADIX: i64 = 16 98const FS_PERMIL: i64 = 1000 99const FS_DIRMODE: i64 = 0x1ed 100const FS_PLANE_ARGS: i64 = 10 101// A worklist line carries a label, a title, a url and a mirror path. Each of those four is already bounded 102// by FS_URLCAP or FS_PATHCAP elsewhere in this organ, so the line bound is DERIVED from those bounds 103// rather than picked: it is not a ceiling anyone has to guess. 104const FS_LINECAP: i64 = 4 * 2048 + 1024 105// At most TWO outside items may be proposed against any ONE deficit row. A third is evidence the seed is 106// too broad, not that the gap is bigger -- so this is a discrimination bound, not a budget. 107const FS_PROPS_PER_ROW: i64 = 2 108 109func fs_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n } 110func fs_w(s: *u8) -> i64 { sys_write(1, s, fs_slen(s)); return 0 } 111func fs_wn(base: *u8, off: i64, len: i64) -> i64 { 112 if len <= 0 { return 0 } 113 sys_write(1, ((base as i64) + off) as *u8, len) 114 return 0 115} 116func fs_n(v: i64) -> i64 { nxi_fd(1, v); return 0 } 117func fs_cat(dst: *u8, pos: i64, s: *u8) -> i64 { 118 var p: i64 = pos 119 var i: i64 = 0 120 let n: i64 = fs_slen(s) 121 while i < n { dst[p] = s[i]; p = p + 1; i = i + 1 } 122 return p 123} 124func fs_catn(dst: *u8, pos: i64, src: *u8, a: i64, b: i64) -> i64 { 125 var p: i64 = pos 126 var i: i64 = a 127 while i < b { dst[p] = src[i]; p = p + 1; i = i + 1 } 128 return p 129} 130func fs_eol(buf: *u8, n: i64, i: i64) -> i64 { 131 var e: i64 = i 132 while e < n { if buf[e] == (FS_NL as u8) { return e } e = e + 1 } 133 return n 134} 135// literal search of buf[from..n) -- index of the FIRST byte of the match, or -1. 136func fs_find(buf: *u8, n: i64, from: i64, lit: *u8) -> i64 { 137 let l: i64 = fs_slen(lit) 138 if l <= 0 { return 0 - 1 } 139 if n < l { return 0 - 1 } 140 var i: i64 = from 141 if i < 0 { i = 0 } 142 while i <= n - l { 143 var j: i64 = 0 144 var m: i64 = 1 145 while j < l { if buf[i+j] != lit[j] { m = 0; j = l } else { j = j + 1 } } 146 if m == 1 { return i } 147 i = i + 1 148 } 149 return 0 - 1 150} 151// THE ITEM BOUNDARY. Returns the offset one past this item's last byte: the next delimiter after this 152// one, or n when this is the last item. Every field extraction is bounded by it, so a field absent from 153// an item can never be satisfied by the NEXT item's copy of that field. 154func fs_item_end(buf: *u8, n: i64, it: i64, idlm: *u8) -> i64 { 155 let e: i64 = fs_find(buf, n, it + fs_slen(idlm), idlm) 156 if e < 0 { return n } 157 return e 158} 159// alphanumeric fold: letters lowered, digits kept, everything else -> 0 (a separator). 160func fs_fold(c: i64) -> i64 { 161 if c >= FS_ZERO { if c <= FS_NINE { return c } } 162 if c >= FS_LOA { if c <= FS_LOZ { return c } } 163 if c >= FS_UPA { if c <= FS_UPZ { return c + (FS_LOA - FS_UPA) } } 164 return 0 165} 166func fs_streq(a: *u8, ao: i64, ae: i64, lit: *u8) -> i64 { 167 let l: i64 = fs_slen(lit) 168 if ae - ao != l { return 0 } 169 var i: i64 = 0 170 while i < l { if a[ao+i] != lit[i] { return 0 } i = i + 1 } 171 return 1 172} 173func fs_prefix(a: *u8, ao: i64, ae: i64, lit: *u8) -> i64 { 174 let l: i64 = fs_slen(lit) 175 if ae - ao < l { return 0 } 176 var i: i64 = 0 177 while i < l { if a[ao+i] != lit[i] { return 0 } i = i + 1 } 178 return 1 179} 180func fs_is_row(buf: *u8, i: i64, le: i64) -> i64 { 181 if le <= i { return 0 } 182 let f: i64 = buf[i] as i64 183 if f == FS_HASH { return 0 } 184 if f == FS_AT { return 0 } 185 if f == FS_NL { return 0 } 186 return 1 187} 188func fs_pipes(buf: *u8, i: i64, le: i64, pos: *i64) -> i64 { 189 var n: i64 = 0 190 var k: i64 = i 191 while k < le { 192 if buf[k] == (FS_PIPE as u8) { 193 if n < FS_MAXP { pos[n] = k; n = n + 1 } 194 } 195 k = k + 1 196 } 197 return n 198} 199func fs_digit_at(buf: *u8, a: i64, b: i64) -> i64 { 200 var i: i64 = a 201 while i < b { 202 let c: i64 = buf[i] as i64 203 if c >= FS_ZERO { if c <= FS_NINE { return c - FS_ZERO } } 204 i = i + 1 205 } 206 return 0 - 1 207} 208func fs_atoi(s: *u8) -> i64 { 209 var v: i64 = 0 210 var any: i64 = 0 211 var i: i64 = 0 212 while s[i] != (0 as u8) { 213 let c: i64 = s[i] as i64 214 if c >= FS_ZERO { if c <= FS_NINE { v = v * 10 + (c - FS_ZERO); any = 1 } } 215 i = i + 1 216 } 217 if any == 0 { return 0 - 1 } 218 return v 219} 220 221// ------------------------------------------------------------------------------------------------- 222// CONFIG. Every threshold lives in knowledge/frontier_scan.conf WITH ITS DERIVATION IN THE ROW. 223// A MISSING CONF REFUSES AND NAMES THE FIX -- it never falls back to a number nobody measured, because 224// AN UNMEASURED BUDGET IS NOT CONSERVATIVE JUST BECAUSE IT IS SMALL. 225// ------------------------------------------------------------------------------------------------- 226func fs_conf_get(cb: *u8, cn: i64, key: *u8) -> i64 { 227 let pos: *i64 = sys_mmap(8 * FS_MAXP) as *i64 228 var i: i64 = 0 229 while i < cn { 230 let le: i64 = fs_eol(cb, cn, i) 231 if fs_is_row(cb, i, le) == 1 { 232 let np: i64 = fs_pipes(cb, i, le, pos) 233 if np >= 2 { 234 if fs_streq(cb, i, pos[0], key) == 1 { 235 let v: i64 = fs_digit_at(cb, pos[0] + 1, pos[1]) 236 if v < 0 { return 0 - 1 } 237 var acc: i64 = 0 238 var q: i64 = pos[0] + 1 239 var any: i64 = 0 240 while q < pos[1] { 241 let c: i64 = cb[q] as i64 242 if c >= FS_ZERO { if c <= FS_NINE { acc = acc * 10 + (c - FS_ZERO); any = 1 } } 243 q = q + 1 244 } 245 if any == 1 { return acc } 246 return 0 - 1 247 } 248 } 249 } 250 i = le + 1 251 } 252 return 0 - 1 253} 254 255// ------------------------------------------------------------------------------------------------- 256// TOKEN COVERAGE. "Is this outside title already described by something on our own board?" 257// COVERED when at least cover_permil of its content tokens already appear in the domain's labels, row 258// notes and citation prose. Tokens shorter than min_token are dropped as stopword-class noise. 259// The direction of error is deliberate: a FALSE COVERED silently loses a proposal, a FALSE NEW costs a 260// seat one glance -- so the bar sits where a HALF-described title still counts as new. 261// ------------------------------------------------------------------------------------------------- 262func fs_tok_in(hay: *u8, hn: i64, tok: *u8, tl: i64) -> i64 { 263 if tl <= 0 { return 0 } 264 var i: i64 = 0 265 while i <= hn - tl { 266 var j: i64 = 0 267 var m: i64 = 1 268 while j < tl { 269 if fs_fold(hay[i+j] as i64) != (tok[j] as i64) { m = 0; j = tl } else { j = j + 1 } 270 } 271 if m == 1 { 272 var okl: i64 = 1 273 if i > 0 { if fs_fold(hay[i-1] as i64) != 0 { okl = 0 } } 274 if i + tl < hn { if fs_fold(hay[i+tl] as i64) != 0 { okl = 0 } } 275 if okl == 1 { return 1 } 276 } 277 i = i + 1 278 } 279 return 0 280} 281func fs_cover_permil(title: *u8, a: i64, b: i64, corp: *u8, cn: i64, min_token: i64, tok: *u8) -> i64 { 282 var total: i64 = 0 283 var hit: i64 = 0 284 var i: i64 = a 285 var tl: i64 = 0 286 while i <= b { 287 var c: i64 = 0 288 if i < b { c = fs_fold(title[i] as i64) } 289 if c == 0 { 290 if tl >= min_token { 291 total = total + 1 292 if fs_tok_in(corp, cn, tok, tl) == 1 { hit = hit + 1 } 293 } 294 tl = 0 295 } else { 296 if tl < FS_TXTCAP - 1 { tok[tl] = c as u8; tl = tl + 1 } 297 } 298 i = i + 1 299 } 300 // A TITLE WITH NO SCORABLE TOKEN IS UNOBSERVABLE, NOT NEW. Returning full coverage makes it COVERED, 301 // i.e. the instrument abstains instead of manufacturing a proposal out of nothing. 302 if total == 0 { return FS_PERMIL } 303 return (hit * FS_PERMIL) / total 304} 305 306// URL-SAFE SEED, AND THE FIRST CUT OF THIS FUNCTION IS WHY THE FIRST REPLAY MISSED. 307// v1 kept the first maxtok alphanumeric runs of the row label verbatim. On a real board that produced 308// `anim+paired+two+character` and `skin+albedo+driven+by`: the SECTION TAG ("ANIM:", "SKIN:") and the 309// stopwords ("two", "by", "in") went into the query, arXiv matched nothing usable, and -- because the 310// request still returned HTTP 200 with the newest submissions -- the loop happily proposed a Bose-Einstein 311// condensate paper against a skin-shader row. ★★★★★★A SEED THAT MATCHES NOTHING RETURNS A SUCCESSFUL 312// RESPONSE FULL OF THE WRONG THING, AND EVERY DOWNSTREAM FILTER THEN SCORES NOISE HONESTLY. 313// v2 therefore: drop the section tag, drop tokens below min_token, cap at maxtok, and JOIN WITH THE 314// SOURCE'S OWN OPERATOR (arXiv needs +AND+ or it ORs into the whole archive; HN wants plain +). 315func fs_seed_q(dst: *u8, src: *u8, a: i64, b: i64, cap: i64, maxtok: i64, min_token: i64, join: *u8) -> i64 { 316 // A section tag is a short word before a colon at the head of a board label (CREATOR, SKIN, BODY, 317 // ANIM, SIM, WORLD, PLATFORM, MESH, HAIR). FS_SECTION_MAX covers the longest of those with headroom 318 // and is short enough that it can never swallow a sentence that merely contains a colon. 319 var s: i64 = a 320 var k: i64 = a 321 var lim: i64 = a + FS_SECTION_MAX 322 if lim > b { lim = b } 323 while k < lim { if src[k] == (FS_COLON as u8) { s = k + 1; k = lim } else { k = k + 1 } } 324 let jl: i64 = fs_slen(join) 325 var p: i64 = 0 326 var toks: i64 = 0 327 var tl: i64 = 0 328 let tok: *u8 = sys_mmap(FS_TXTCAP) 329 var i: i64 = s 330 var stop: i64 = 0 331 while i <= b { 332 if stop == 0 { 333 var c: i64 = 0 334 if i < b { c = fs_fold(src[i] as i64) } 335 if c == 0 { 336 if tl >= min_token { 337 if p + tl + jl < cap - 2 { 338 if toks > 0 { var jj: i64 = 0; while jj < jl { dst[p] = join[jj]; p = p + 1; jj = jj + 1 } } 339 var m: i64 = 0 340 while m < tl { dst[p] = tok[m]; p = p + 1; m = m + 1 } 341 toks = toks + 1 342 if toks >= maxtok { stop = 1 } 343 } 344 } 345 tl = 0 346 } else { 347 if tl < FS_TXTCAP - 1 { tok[tl] = c as u8; tl = tl + 1 } 348 } 349 } 350 i = i + 1 351 } 352 dst[p] = 0 as u8 353 return p 354} 355 356// Stable 32-bit id for a url, printed as 8 hex digits. THIS IS WHAT MAKES THE PLANE PUT IDEMPOTENT: 357// the same proposal re-scanned tomorrow upserts its own row instead of growing a duplicate every beat. 358func fs_urlhash(buf: *u8, a: i64, b: i64) -> i64 { 359 var h: i64 = 0 360 var i: i64 = a 361 while i < b { h = ((h * FS_HASH_BASE) + (buf[i] as i64)) & FS_HASH_MASK; i = i + 1 } 362 return h 363} 364func fs_hex(dst: *u8, pos: i64, v: i64) -> i64 { 365 let digits: *u8 = "0123456789abcdef" as *u8 366 var p: i64 = pos 367 var k: i64 = FS_HEXDIG - 1 368 while k >= 0 { 369 let nib: i64 = (v / (1 << (FS_HEXSHIFT * k))) % FS_HEXRADIX 370 dst[p] = digits[nib] 371 p = p + 1 372 k = k - 1 373 } 374 return p 375} 376 377// A <domain> CONTAINING A SLASH IS A PATH PREFIX, NOT A DOMAIN NAME. That one branch is what lets the 378// gate assemble its fixtures under /tmp/<gate>/ (a gate must not share its fixture with a production 379// beat) and lets the metahuman REPLAY reconstruct a historical board WITHOUT writing anything into the 380// live knowledge/compare tree, where nx_domain_admit --all and the regen census would both consume it. 381func fs_has_slash(s: *u8) -> i64 { 382 var i: i64 = 0 383 while s[i] != (0 as u8) { if s[i] == (FS_SLASH as u8) { return 1 } i = i + 1 } 384 return 0 385} 386func fs_basename(s: *u8) -> i64 { 387 var i: i64 = 0 388 var last: i64 = 0 - 1 389 while s[i] != (0 as u8) { if s[i] == (FS_SLASH as u8) { last = i } i = i + 1 } 390 return last + 1 391} 392func fs_cmp_path(dst: *u8, dom: *u8, ext: *u8) -> i64 { 393 var p: i64 = 0 394 if fs_has_slash(dom) == 0 { p = fs_cat(dst, 0, "buildroot/knowledge/compare/" as *u8) } 395 p = fs_cat(dst, p, dom) 396 p = fs_cat(dst, p, ext) 397 dst[p] = 0 as u8 398 return p 399} 400 401// ------------------------------------------------------------------------------------------------- 402// SEEDS. .axes field 4 first, then matrix labels ALWAYS. Emitting the SOURCE of each seed is the point: 403// a seed nobody can trace back to the board is a hand-typed seed wearing a data costume. 404// ------------------------------------------------------------------------------------------------- 405func fs_emit_seeds(dom: *u8) -> i64 { 406 let path: *u8 = sys_mmap(FS_PATHCAP) 407 let pos: *i64 = sys_mmap(8 * FS_MAXP) as *i64 408 let alen: *i64 = sys_mmap(16) as *i64 409 var seeds: i64 = 0 410 411 // .axes NOW RESOLVES ACROSS BOTH COMPARE TREES (2026-09-01), STRICTLY ADDITIVELY. 412 // The original single read is kept EXACTLY as it was and runs FIRST, so no case that worked before 413 // can change; the two-tree resolver is consulted ONLY when that read missed. This can turn an ABSENT 414 // into a FOUND and never a FOUND into anything else -- the same shape da_read_2dir uses one organ over. 415 // A SLASH IN dom IS A LITERAL FIXTURE PATH (the gate passes /tmp/...), and it must never be redirected 416 // into a knowledge tree, so the fallback is gated on a bare domain name -- the same discrimination 417 // fs_cmp_path already makes. 418 // AUTHORED ORDER: .axes is hand-written and rendered by no page, so the bare knowledge tree is asked 419 // first. ct_readall_2dir sizes from the file, so there is no cap to guess and no silent truncation. 420 // The reported path is rebuilt from PRIMARY rather than assumed: the buildroot read above has already 421 // missed, and secondary IS buildroot, so a hit here can only have come from primary. 422 let awhich: *i64 = sys_mmap(16) as *i64 423 awhich[0] = CT_TREE_NONE 424 fs_cmp_path(path, dom, ".axes" as *u8) 425 var ab: *u8 = sys_read_file(path, alen) 426 if fs_has_slash(dom) == 0 { 427 if (ab as i64) == 0 { 428 ab = ct_readall_2dir(ct_first_authored(), ct_second_authored(), dom, ".axes" as *u8, alen, awhich) 429 if (ab as i64) != 0 { 430 var q: i64 = fs_cat(path, 0, CT_DIR_PRIMARY) 431 q = fs_cat(path, q, dom) 432 q = fs_cat(path, q, ".axes" as *u8) 433 path[q] = 0 as u8 434 } 435 } 436 } 437 if (ab as i64) != 0 { 438 let an: i64 = alen[0] 439 if an > 0 { 440 fs_w("SEED-SOURCE axes " as *u8); fs_w(path); fs_w("\n" as *u8) 441 var i: i64 = 0 442 while i < an { 443 let le: i64 = fs_eol(ab, an, i) 444 if fs_is_row(ab, i, le) == 1 { 445 let np: i64 = fs_pipes(ab, i, le, pos) 446 if np >= 3 { 447 var s: i64 = pos[2] + 1 448 var k: i64 = s 449 while k <= le { 450 var cut: i64 = 0 451 if k == le { cut = 1 } else { if ab[k] == (FS_SEMI as u8) { cut = 1 } } 452 if cut == 1 { 453 if k > s { fs_w("SEED axes " as *u8); fs_wn(ab, s, k - s); fs_w("\n" as *u8); seeds = seeds + 1 } 454 s = k + 1 455 } 456 k = k + 1 457 } 458 } 459 } 460 i = le + 1 461 } 462 } 463 } else { fs_w("SEED-SOURCE axes ABSENT (matrix labels carry the whole seed set for this domain)\n" as *u8) } 464 465 fs_cmp_path(path, dom, ".matrix" as *u8) 466 let mlen: *i64 = sys_mmap(16) as *i64 467 let mb: *u8 = sys_read_file(path, mlen) 468 if (mb as i64) == 0 { fs_w("SEEDS-REFUSED no-matrix " as *u8); fs_w(path); fs_w("\n" as *u8); return 0 - 1 } 469 let mn: i64 = mlen[0] 470 fs_w("SEED-SOURCE matrix " as *u8); fs_w(path); fs_w("\n" as *u8) 471 var j: i64 = 0 472 while j < mn { 473 let le2: i64 = fs_eol(mb, mn, j) 474 if fs_is_row(mb, j, le2) == 1 { 475 let np2: i64 = fs_pipes(mb, j, le2, pos) 476 if np2 >= 1 { 477 fs_w("SEED matrix " as *u8); fs_wn(mb, j, pos[0] - j); fs_w("\n" as *u8) 478 seeds = seeds + 1 479 } 480 } 481 j = le2 + 1 482 } 483 fs_w("SEEDS total=" as *u8); fs_n(seeds); fs_w("\n" as *u8) 484 return seeds 485} 486 487// ------------------------------------------------------------------------------------------------- 488// CAPABILITY RANK FOR A NOMINAL CODE (2026-09-01) -- the fix for a comparison that contradicted its 489// own conf's stated derivation. 490// The matrix codebook is 0=No 1=Yes 2=Best 3=Part. That is NOMINAL, not ordinal: Part is a WEAKER 491// capability than Yes, but it is a LARGER integer. fs_deficit compared the raw code with 492// `c >= lead_code`, so at the shipped lead_code=2 a rival coded 3 (Part) COUNTED AS LEADING while a 493// rival coded 1 (Yes) did NOT -- the exact inverse of what knowledge/frontier_scan.conf says that key 494// means: "2 is exactly the statement a rival is Best at this". 495// WORSE THAN A MIS-SCORE, IT IS A BLIND SPOT: with no rival coded 2 or 3, `leads` stays 0 and the row 496// is never a deficit at all -- so the single clearest gap class, EVERY RIVAL FULLY HAS THIS AND WE DO 497// NOT (all rivals coded 1), was invisible to the estate's only autonomous frontier-noticer. 498// MEASURED CONSEQUENCE on the live search board: is_shard -- where Mojeek's own pinned mirror records 499// nine billion pages, coded 1=Yes -- ranked BELOW hs_render, where two rivals are merely Part. 500// FIX: rank by CAPABILITY STRENGTH and compare ranks, so the conf key keeps its declared meaning and 501// any future value of lead_code also means what it says. No(0)=0 Part(3)=1 Yes(1)=2 Best(2)=3. 502// SCOPE HELD DELIBERATELY NARROW: only the LEAD test changes. The score line below is left alone -- 503// widening the scoring policy in the same edit as a correctness fix would make the two impossible to 504// tell apart in the next measurement. 505// ★A NUMERIC COMPARISON ON A NOMINAL CODE IS A BUG WEARING ARITHMETIC. 506// ------------------------------------------------------------------------------------------------- 507const FS_CODE_PART: i64 = 3 508func fs_code_rank(c: i64) -> i64 { 509 if c == FS_CODE_BEST { return 3 } 510 if c == FS_CODE_YES { return 2 } 511 if c == FS_CODE_PART { return 1 } 512 return 0 513} 514 515// ------------------------------------------------------------------------------------------------- 516// DEFICIT. THE REASON TRAVELS WITH THE COUNT: every row prints how many rivals lead and what our own 517// symbol is, so the worklist is triageable without re-running anything. 518// ------------------------------------------------------------------------------------------------- 519func fs_deficit(mb: *u8, mn: i64, lead_code: i64, rowa: *i64, rowb: *i64, score: *i64, verbose: i64) -> i64 { 520 let pos: *i64 = sys_mmap(8 * FS_MAXP) as *i64 521 var found: i64 = 0 522 var rows: i64 = 0 523 var i: i64 = 0 524 while i < mn { 525 let le: i64 = fs_eol(mb, mn, i) 526 if fs_is_row(mb, i, le) == 1 { 527 let np: i64 = fs_pipes(mb, i, le, pos) 528 if np >= 8 { 529 rows = rows + 1 530 let exceed: i64 = fs_digit_at(mb, pos[2] + 1, pos[3]) 531 var absent: i64 = 0 532 if fs_prefix(mb, pos[1] + 1, pos[2], "_ABSENT_" as *u8) == 1 { absent = 1 } 533 var sc: i64 = 0 534 var leads: i64 = 0 535 var k: i64 = 0 536 while k < FS_RIVALS { 537 let c: i64 = fs_digit_at(mb, pos[3+k] + 1, pos[4+k]) 538 if fs_code_rank(c) >= fs_code_rank(lead_code) { leads = leads + 1; sc = sc + FS_CODE_BEST } 539 if c == FS_CODE_YES { sc = sc + FS_CODE_YES } 540 k = k + 1 541 } 542 var deficit: i64 = 0 543 if exceed != 1 { if leads > 0 { deficit = 1 } } 544 if deficit == 1 { 545 if absent == 1 { sc = sc + FS_CODE_BEST } 546 if found < FS_MAXROWS { 547 rowa[found] = i 548 rowb[found] = pos[0] 549 score[found] = sc 550 found = found + 1 551 } 552 if verbose == 1 { 553 fs_w("DEFICIT score=" as *u8); fs_n(sc) 554 fs_w(" rivals_leading=" as *u8); fs_n(leads) 555 fs_w(" our_symbol=" as *u8); fs_wn(mb, pos[1] + 1, pos[2] - (pos[1] + 1)) 556 fs_w(" row=" as *u8); fs_wn(mb, i, pos[0] - i) 557 fs_w("\n" as *u8) 558 } 559 } 560 } 561 } 562 i = le + 1 563 } 564 var a: i64 = 0 565 while a < found { 566 var best: i64 = a 567 var b: i64 = a + 1 568 while b < found { if score[b] > score[best] { best = b } b = b + 1 } 569 if best != a { 570 let ts: i64 = score[a]; score[a] = score[best]; score[best] = ts 571 let ta: i64 = rowa[a]; rowa[a] = rowa[best]; rowa[best] = ta 572 let tb: i64 = rowb[a]; rowb[a] = rowb[best]; rowb[best] = tb 573 } 574 a = a + 1 575 } 576 if verbose == 1 { 577 fs_w("DEFICIT-PARTITION rows_total=" as *u8); fs_n(rows) 578 fs_w(" deficit=" as *u8); fs_n(found) 579 fs_w(" not_deficit=" as *u8); fs_n(rows - found) 580 fs_w(" (deficit plus not_deficit equals rows_total)\n" as *u8) 581 } 582 return found 583} 584 585// ------------------------------------------------------------------------------------------------- 586// FETCH ONE SOURCE by COMPOSING nx_research_fetch -- the estate's ONE fetcher, which mirrors into 587// knowledge/fetched and can be pinned by nx_filehash. TLS is never re-implemented here. 588// Writes the saved raw path into savepath; returns its length, or -1. 589// ------------------------------------------------------------------------------------------------- 590func fs_fetch(url: *u8, tmpout: *u8, savepath: *u8, olen: *i64) -> i64 { 591 let args: *i64 = sys_mmap(32) as *i64 592 args[0] = url as i64 593 var rc: i64 = dep_run_capture("./nx_research_fetch.elf" as *u8, args, 1, tmpout) 594 if rc == 127 { rc = dep_run_capture("_offc/nx_research_fetch.elf" as *u8, args, 1, tmpout) } 595 let ob: *u8 = sys_read_file(tmpout, olen) 596 if (ob as i64) == 0 { return 0 - 1 } 597 let on: i64 = olen[0] 598 let s: i64 = fs_find(ob, on, 0, "SAVED " as *u8) 599 if s < 0 { return 0 - 1 } 600 let p: i64 = s + 6 601 // separate cursor + explicit flag: A LOOP THAT BREAKS BY CLOBBERING ITS OWN CURSOR CANNOT ALSO REPORT 602 // WHERE IT STOPPED, and the answer here IS where it stopped. 603 var q: i64 = p 604 var end: i64 = p 605 var stop: i64 = 0 606 while stop == 0 { 607 if q >= on { end = q; stop = 1 } else { 608 let c: i64 = ob[q] as i64 609 if c == FS_SPACE { end = q; stop = 1 } else { 610 if c == FS_NL { end = q; stop = 1 } else { q = q + 1 } 611 } 612 } 613 } 614 let n: i64 = fs_catn(savepath, 0, ob, p, end) 615 savepath[n] = 0 as u8 616 return n 617} 618 619// ------------------------------------------------------------------------------------------------- 620// EXTRACT + DIFF for one source over one seed. Prints proposals; returns how many it emitted. 621// Partition printed and summed: seen = already_cited + covered_by_board + proposed + over_row_cap + unpaired. 622// EVERY FIELD IS SEARCHED INSIDE ITS OWN ITEM'S EXTENT, never to the end of the buffer. v1 did the latter, 623// so an item missing a field silently borrowed the NEXT item's -- see fs_item_end and the block below. 624// ------------------------------------------------------------------------------------------------- 625func fs_scan_source(dom: *u8, kind: *u8, url: *u8, idlm: *u8, topen: *u8, tclose: *u8, 626 uopen: *u8, uclose: *u8, corp: *u8, corpn: i64, refs: *u8, refsn: i64, 627 label: *u8, la: i64, lb: i64, max_items: i64, cover_permil: i64, min_token: i64, 628 wl: *u8, wlout: *i64, tok: *u8, savepath: *u8, olen: *i64, rlen: *i64) -> i64 { 629 let tmpout: *u8 = "/tmp/nx_frontier_scan/fetch.out" as *u8 630 let got: i64 = fs_fetch(url, tmpout, savepath, olen) 631 if got <= 0 { 632 fs_w(" SOURCE-UNREACHABLE kind=" as *u8); fs_w(kind) 633 fs_w(" url=" as *u8); fs_w(url) 634 fs_w(" (UNOBSERVABLE, not zero -- an axis that cannot see must abstain, not acquit)\n" as *u8) 635 return 0 636 } 637 let rb: *u8 = sys_read_file(savepath, rlen) 638 if (rb as i64) == 0 { 639 fs_w(" SOURCE-UNREADABLE mirror=" as *u8); fs_w(savepath); fs_w("\n" as *u8) 640 return 0 641 } 642 let rn: i64 = rlen[0] 643 fs_w(" SOURCE kind=" as *u8); fs_w(kind) 644 fs_w(" mirror=" as *u8); fs_w(savepath) 645 fs_w(" bytes=" as *u8); fs_n(rn); fs_w("\n" as *u8) 646 647 var seen: i64 = 0 648 var cited: i64 = 0 649 var covered: i64 = 0 650 var proposed: i64 = 0 651 var overcap: i64 = 0 652 var unpaired: i64 = 0 653 var wp: i64 = wlout[0] 654 var cur: i64 = 0 655 var go: i64 = 1 656 while go == 1 { 657 if seen >= max_items { go = 0 } else { 658 let it: i64 = fs_find(rb, rn, cur, idlm) 659 if it < 0 { go = 0 } else { 660 // ---- ITEM EXTENT: THE FIX (2026-08-20, lane E) ---------------------------------------- 661 // ★★★★★★A PROPOSAL WHOSE URL DOES NOT BELONG TO ITS TITLE IS A FABRICATED CITATION IN THE 662 // MAKING -- the same defect class this lane spent a day retracting off /compare/charsim, 663 // caught one step UPSTREAM, before it can ever reach a refs row. 664 // v1 searched every field from the item delimiter TO THE END OF THE BUFFER, so an item 665 // that lacks a field silently borrowed the next item's. MEASURED LIVE on HN Algolia: 666 // Ask HN and Launch HN text posts carry NO "url" key at all (the mirror holds story_text 667 // instead), and TWO ADJACENT url-less items both reported the SAME downstream url under 668 // DIFFERENT titles. The bound is the item's own end; a field absent from it makes the 669 // item UNPAIRED, which is its own bucket -- never a borrowed neighbour. 670 // fs_find's own contract does the bounding for free: it requires the WHOLE literal inside 671 // [0,n), so passing the item end as n cannot match a literal straddling the boundary. 672 let ie: i64 = fs_item_end(rb, rn, it, idlm) 673 let ts: i64 = fs_find(rb, ie, it, topen) 674 let us: i64 = fs_find(rb, ie, it, uopen) 675 if ts < 0 { seen = seen + 1; unpaired = unpaired + 1; cur = it + fs_slen(idlm) } else { 676 if us < 0 { seen = seen + 1; unpaired = unpaired + 1; cur = it + fs_slen(idlm) } else { 677 let ta: i64 = ts + fs_slen(topen) 678 let te: i64 = fs_find(rb, ie, ta, tclose) 679 let ua: i64 = us + fs_slen(uopen) 680 let ue: i64 = fs_find(rb, ie, ua, uclose) 681 if te < 0 { seen = seen + 1; unpaired = unpaired + 1; cur = it + fs_slen(idlm) } else { 682 if ue < 0 { seen = seen + 1; unpaired = unpaired + 1; cur = it + fs_slen(idlm) } else { 683 seen = seen + 1 684 cur = it + fs_slen(idlm) 685 // ALREADY CITED? the refs file carries the url verbatim in field 4. 686 var already: i64 = 0 687 if refsn > 0 { 688 let ul: i64 = ue - ua 689 var z: i64 = 0 690 var hit: i64 = 0 691 while z <= refsn - ul { 692 var j: i64 = 0 693 var m: i64 = 1 694 while j < ul { if refs[z+j] != rb[ua+j] { m = 0; j = ul } else { j = j + 1 } } 695 if m == 1 { hit = 1; z = refsn } 696 z = z + 1 697 } 698 already = hit 699 } 700 if already == 1 { cited = cited + 1 } else { 701 let cov: i64 = fs_cover_permil(rb, ta, te, corp, corpn, min_token, tok) 702 if cov >= cover_permil { covered = covered + 1 } else { 703 if proposed >= FS_PROPS_PER_ROW { overcap = overcap + 1 } else { 704 proposed = proposed + 1 705 fs_w(" PROPOSAL domain=" as *u8); fs_w(dom) 706 fs_w(" kind=" as *u8); fs_w(kind) 707 fs_w(" cover_permil=" as *u8); fs_n(cov) 708 fs_w("\n" as *u8) 709 fs_w(" challenges_row: " as *u8); fs_wn(label, la, lb - la); fs_w("\n" as *u8) 710 fs_w(" title: " as *u8); fs_wn(rb, ta, te - ta); fs_w("\n" as *u8) 711 fs_w(" url: " as *u8); fs_wn(rb, ua, ue - ua); fs_w("\n" as *u8) 712 fs_w(" mirror: " as *u8); fs_w(savepath); fs_w("\n" as *u8) 713 wp = fs_cat(wl, wp, "PROPOSAL|" as *u8) 714 wp = fs_cat(wl, wp, dom) 715 wp = fs_cat(wl, wp, "|" as *u8) 716 wp = fs_catn(wl, wp, label, la, lb) 717 wp = fs_cat(wl, wp, "|" as *u8) 718 wp = fs_catn(wl, wp, rb, ta, te) 719 wp = fs_cat(wl, wp, "|" as *u8) 720 wp = fs_catn(wl, wp, rb, ua, ue) 721 wp = fs_cat(wl, wp, "|" as *u8) 722 wp = fs_cat(wl, wp, savepath) 723 wp = fs_cat(wl, wp, "|" as *u8) 724 wp = fs_cat(wl, wp, kind) 725 wp = fs_cat(wl, wp, "|OPEN" as *u8) 726 wl[wp] = FS_NL as u8 727 wp = wp + 1 728 } 729 } 730 } 731 } 732 } 733 } 734 } 735 } 736 } 737 } 738 fs_w(" ITEMS seen=" as *u8); fs_n(seen) 739 fs_w(" already_cited=" as *u8); fs_n(cited) 740 fs_w(" covered_by_board=" as *u8); fs_n(covered) 741 fs_w(" proposed=" as *u8); fs_n(proposed) 742 fs_w(" over_row_cap=" as *u8); fs_n(overcap) 743 fs_w(" unpaired=" as *u8); fs_n(unpaired) 744 fs_w(" (the five buckets sum to seen)\n" as *u8) 745 wlout[0] = wp 746 return proposed 747} 748 749// ================================================================================================= 750// ATTEST (2026-09-06). Operator: "use and upgrade the nishi research fetch system and expand its fan out 751// ... so siggraph 2026 and all those other state of the art research areas like github gitea etc all get 752// evaluated." Two legs over the SAME source rows the scan reads (a DATED row carries two more fields: 753// date-open and date-close, or month=YYYY-MM in date-open when a listing has one month for every item, 754// as a conference index does): 755// ATTEST LEG re-fetch the listing each sotabar| row cites (its ref's url), read the newest month in it, 756// append barscan|<today>|<ref>|newest=<YYYY-MM> to the plan -- idempotent per date and ref -- 757// so nx_barfresh reads ATTESTED (or STALE when the listing moved) from the estate's own 758// re-reading: "nothing newer this month" is re-earned by a beat, never remembered by a seat. 759// FAN-OUT LEG ask every OTHER dated source the bar's subject, print NEWER / SAME / OLDER / UNDATED per 760// source with the newest item named, and write the NEWER items to a worklist a seat adjudicates. 761// STILL ADMITS NOTHING: a barscan row records that a listing was fetched and read and what its newest 762// month was; the claim about what that month SAYS stays the sotabar| row a seat writes from the worklist. 763// A STATIC listing (no {q} in its url) is FILTERED BY THE BAR'S SUBJECT: an item sharing no content token 764// with the subject is not evidence about it, so a 283-paper conference index reads as the papers on the 765// subject; it is fan-out only, the scan verb never proposes from it (see main). 766// UNDATED is its own answer, never zero: a listing whose items carry no readable date cannot attest a month. 767// ================================================================================================= 768const FS_DASH: i64 = 45 769const FS_CR: i64 = 13 770const FS_MONTH_TAG: *u8 = "month=" 771const FS_MONTH_TAG_LEN: i64 = 6 772const FS_DATED_PIPES: i64 = 10 // src|kind|url|item|topen|tclose|uopen|uclose|join|dopen|dclose 773const FS_ATT_C_BARS: i64 = 0 774const FS_ATT_C_APPENDED: i64 = 1 775const FS_ATT_C_ALREADY: i64 = 2 776const FS_ATT_C_UNATTESTABLE: i64 = 3 777const FS_ATT_C_FETCHES: i64 = 4 778const FS_ATT_C_NEWER: i64 = 5 779const FS_ATT_C_STALE: i64 = 6 780const FS_ATT_C_N: i64 = 8 781const FS_YMBUF: i64 = 16 782const FS_TODAYBUF: i64 = 32 783 784// the month index of the YYYY-MM at rb[a..b), or -1 -- ONE reader, the bar ruler's 785func fs_ym_at(rb: *u8, a: i64, b: i64) -> i64 { 786 if b - a < BF_YM_LEN { return 0 - 1 } 787 let v: i64 = bf_parse_ym(((rb as i64) + a) as *u8, b - a) 788 if v == BF_NONE { return 0 - 1 } 789 return v 790} 791// month=YYYY-MM in a date-open field -> that month; anything else -> -1 (read the item's own date) 792func fs_fixed_month(spec: *u8) -> i64 { 793 let n: i64 = fs_slen(spec) 794 if fs_prefix(spec, 0, n, FS_MONTH_TAG) == 0 { return 0 - 1 } 795 return fs_ym_at(spec, FS_MONTH_TAG_LEN, n) 796} 797func fs_w_ym(b: *u8, ix: i64) -> i64 { bf_ym_write(b, 0, ix); fs_w(b); return 0 } 798func fs_catn_num(dst: *u8, pos: i64, v: i64) -> i64 { 799 var p: i64 = pos 800 if v == 0 { dst[p] = FS_ZERO as u8; return p + 1 } 801 var m: i64 = v 802 if m < 0 { dst[p] = FS_DASH as u8; p = p + 1; m = 0 - m } 803 let tmp: *u8 = sys_mmap(FS_TODAYBUF) 804 var k: i64 = 0 805 while m > 0 { tmp[k] = (FS_ZERO + (m - (m / 10) * 10)) as u8; m = m / 10; k = k + 1 } 806 while k > 0 { k = k - 1; dst[p] = tmp[k]; p = p + 1 } 807 return p 808} 809// today as YYYY-MM-DD through the estate's civil date -- the barscan row's date field 810func fs_today(dst: *u8) -> i64 { 811 let ts: *i64 = sys_mmap(BF_CLOCK_WORDS * BF_I64) as *i64 812 ts[0] = 0 813 sys_clock_gettime_real(ts) 814 let y: *i64 = sys_mmap(BF_I64) as *i64 815 let m: *i64 = sys_mmap(BF_I64) as *i64 816 let d: *i64 = sys_mmap(BF_I64) as *i64 817 civil_from_days(ts[0] / BF_SECS_PER_DAY, y, m, d) 818 var o: i64 = bf_ym_write(dst, 0, bf_ym_index(y[0], m[0])) 819 dst[o] = FS_DASH as u8; o = o + 1 820 dst[o] = (d[0] / 10 + FS_ZERO) as u8; o = o + 1 821 dst[o] = (d[0] - (d[0] / 10) * 10 + FS_ZERO) as u8; o = o + 1 822 dst[o] = 0 as u8 823 return o 824} 825// does the item [it,ie) mention ANY content token (min_token or longer) of the subject subj[so..so+sn)? 826func fs_item_mentions(rb: *u8, it: i64, ie: i64, subj: *u8, so: i64, sn: i64, min_token: i64, tok: *u8) -> i64 { 827 let hay: *u8 = ((rb as i64) + it) as *u8 828 let hn: i64 = ie - it 829 var tl: i64 = 0 830 var i: i64 = so 831 while i <= so + sn { 832 var c: i64 = 0 833 if i < so + sn { c = fs_fold(subj[i] as i64) } 834 if c == 0 { 835 if tl >= min_token { if fs_tok_in(hay, hn, tok, tl) == 1 { return 1 } } 836 tl = 0 837 } else { if tl < FS_TXTCAP - 1 { tok[tl] = c as u8; tl = tl + 1 } } 838 i = i + 1 839 } 840 return 0 841} 842// a field (open..close) INSIDE the item's own extent: its length with off[0]=start, or -1 843func fs_item_field(rb: *u8, it: i64, ie: i64, open: *u8, close: *u8, off: *i64) -> i64 { 844 let s: i64 = fs_find(rb, ie, it, open) 845 if s < 0 { return 0 - 1 } 846 let a: i64 = s + fs_slen(open) 847 let e: i64 = fs_find(rb, ie, a, close) 848 if e < 0 { return 0 - 1 } 849 off[0] = a 850 return e - a 851} 852// THE MONTH READER. Walks the items of a mirrored listing (each bounded by its own extent), reads the date 853// between dopen and dclose -- or takes the FIXED month when the source declares one -- and returns the 854// newest month index, or -1 when no item could be dated (UNDATED, never the epoch). With sn > 0 only items 855// mentioning the subject count (a static listing is filtered by the bar's subject). 856// cnt[0]=items seen, cnt[1]=items dated, cnt[2]=offset of the newest item (-1 if none), cnt[3..4]=its date span. 857func fs_newest_month(rb: *u8, rn: i64, idlm: *u8, dopen: *u8, dclose: *u8, fixed: i64, max_items: i64, 858 subj: *u8, so: i64, sn: i64, min_token: i64, tok: *u8, cnt: *i64) -> i64 { 859 var best: i64 = 0 - 1 860 var seen: i64 = 0 861 var dated: i64 = 0 862 var cur: i64 = 0 863 var go: i64 = 1 864 cnt[2] = 0 - 1; cnt[3] = 0; cnt[4] = 0 865 while go == 1 { 866 if seen >= max_items { go = 0 } else { 867 let it: i64 = fs_find(rb, rn, cur, idlm) 868 if it < 0 { go = 0 } else { 869 let ie: i64 = fs_item_end(rb, rn, it, idlm) 870 cur = it + fs_slen(idlm) 871 var take: i64 = 1 872 if sn > 0 { take = fs_item_mentions(rb, it, ie, subj, so, sn, min_token, tok) } 873 if take == 1 { 874 seen = seen + 1 875 var ym: i64 = 0 - 1 876 var da: i64 = 0 877 var de: i64 = 0 878 if fixed >= 0 { ym = fixed } else { 879 let ds: i64 = fs_find(rb, ie, it, dopen) 880 if ds >= 0 { 881 da = ds + fs_slen(dopen) 882 de = fs_find(rb, ie, da, dclose) 883 if de > da { ym = fs_ym_at(rb, da, de) } 884 } 885 } 886 if ym >= 0 { 887 dated = dated + 1 888 if ym > best { best = ym; cnt[2] = it; cnt[3] = da; cnt[4] = de } 889 } 890 } 891 } 892 } 893 } 894 cnt[0] = seen 895 cnt[1] = dated 896 return best 897} 898// Append ONE barscan row to a plan, idempotent per (date, ref): the same attestation re-run the same day is a 899// no-op, so a beat cannot grow a plan by a row per tick. 1 appended, 0 already present, -1 unwritable. 900func fs_attest_row(plan: *u8, refkey: *u8, today: *u8, ym: i64, note: *u8) -> i64 { 901 let plen: *i64 = sys_mmap(16) as *i64 902 let pb: *u8 = sys_read_file(plan, plen) 903 if (pb as i64) == 0 { return 0 - 1 } 904 let pn: i64 = plen[0] 905 let key: *u8 = sys_mmap(FS_TXTCAP) 906 var k: i64 = fs_cat(key, 0, BF_SCAN_TAG) 907 k = fs_cat(key, k, today) 908 k = fs_cat(key, k, "|" as *u8) 909 k = fs_cat(key, k, refkey) 910 k = fs_cat(key, k, "|" as *u8) 911 key[k] = 0 as u8 912 if fs_find(pb, pn, 0, key) >= 0 { return 0 } 913 let row: *u8 = sys_mmap(FS_LINECAP) 914 var r: i64 = fs_cat(row, 0, key) 915 r = fs_cat(row, r, BF_NEWEST_TAG) 916 r = bf_ym_write(row, r, ym) 917 r = fs_cat(row, r, "|" as *u8) 918 r = fs_cat(row, r, note) 919 row[r] = FS_NL as u8; r = r + 1 920 let fd: i64 = sys_openat_append(plan, MODE_0644) 921 if fd < 0 { return 0 - 1 } 922 // a plan whose last byte is not a newline would glue this row onto its previous line 923 if pn > 0 { if pb[pn - 1] != (FS_NL as u8) { sys_write(fd, "\n" as *u8, 1) } } 924 sys_write(fd, row, r) 925 sys_close(fd) 926 return 1 927} 928// ref|<key>|<cite>|<url>|... -> the url span of the row whose key matches; length with off[0]=start, or -1 929func fs_ref_url(refs: *u8, refsn: i64, key: *u8, klen: i64, off: *i64) -> i64 { 930 let pos: *i64 = sys_mmap(8 * FS_MAXP) as *i64 931 var i: i64 = 0 932 while i < refsn { 933 let le: i64 = fs_eol(refs, refsn, i) 934 if fs_is_row(refs, i, le) == 1 { 935 let np: i64 = fs_pipes(refs, i, le, pos) 936 if np >= 4 { if fs_streq(refs, i, pos[0], "ref" as *u8) == 1 { 937 if pos[1] - (pos[0] + 1) == klen { 938 var m: i64 = 1 939 var j: i64 = 0 940 while j < klen { if refs[pos[0] + 1 + j] != key[j] { m = 0; j = klen } else { j = j + 1 } } 941 if m == 1 { off[0] = pos[2] + 1; return pos[3] - (pos[2] + 1) } 942 } 943 } } 944 } 945 i = le + 1 946 } 947 return 0 - 1 948} 949// the nine fields of a DATED source row into NUL-terminated buffers (spos from fs_pipes, sle the row end) 950func fs_src_fields(sb: *u8, spos: *i64, sle: i64, kind: *u8, idlm: *u8, topen: *u8, tclos: *u8, uopen: *u8, uclos: *u8, join: *u8, dopen: *u8, dclos: *u8) -> i64 { 951 var q: i64 = fs_catn(kind, 0, sb, spos[0] + 1, spos[1]); kind[q] = 0 as u8 952 q = fs_catn(idlm, 0, sb, spos[2] + 1, spos[3]); idlm[q] = 0 as u8 953 q = fs_catn(topen, 0, sb, spos[3] + 1, spos[4]); topen[q] = 0 as u8 954 q = fs_catn(tclos, 0, sb, spos[4] + 1, spos[5]); tclos[q] = 0 as u8 955 q = fs_catn(uopen, 0, sb, spos[5] + 1, spos[6]); uopen[q] = 0 as u8 956 q = fs_catn(uclos, 0, sb, spos[6] + 1, spos[7]); uclos[q] = 0 as u8 957 q = fs_catn(join, 0, sb, spos[7] + 1, spos[8]); join[q] = 0 as u8 958 q = fs_catn(dopen, 0, sb, spos[8] + 1, spos[9]); dopen[q] = 0 as u8 959 q = fs_catn(dclos, 0, sb, spos[9] + 1, sle); dclos[q] = 0 as u8 960 return 0 961} 962// substitute {q} in the template sb[a..b) with qbuf into url; returns 1 when the template had a slot, 0 (static) otherwise 963func fs_build_url(url: *u8, sb: *u8, a: i64, b: i64, qbuf: *u8) -> i64 { 964 var up: i64 = 0 965 var t: i64 = a 966 var had: i64 = 0 967 while t < b { 968 var sub: i64 = 0 969 if sb[t] == (FS_LBRACE as u8) { if fs_prefix(sb, t, b, "{q}" as *u8) == 1 { sub = 1 } } 970 if sub == 1 { up = fs_cat(url, up, qbuf); t = t + 3; had = 1 } else { url[up] = sb[t]; up = up + 1; t = t + 1 } 971 } 972 url[up] = 0 as u8 973 return had 974} 975func fs_attest_domain(dom: *u8, dbase: *u8, sb: *u8, sn: i64, today: *u8, max_items: i64, min_token: i64, seed_tokens: i64, tot: *i64) -> i64 { 976 let path: *u8 = sys_mmap(FS_PATHCAP) 977 fs_cmp_path(path, dom, ".plan" as *u8) 978 let plen: *i64 = sys_mmap(16) as *i64 979 let pb: *u8 = sys_read_file(path, plen) 980 if (pb as i64) == 0 { fs_w("ATTEST-REFUSED domain=" as *u8); fs_w(dom); fs_w(" reason=no-plan path=" as *u8); fs_w(path); fs_w("\n" as *u8); return 0 - 1 } 981 let pn: i64 = plen[0] 982 let nbars: i64 = bf_count_rows(pb, pn, BF_BAR_TAG) 983 fs_w("=== nx_frontier_scan attest " as *u8); fs_w(dom); fs_w(" bars=" as *u8); fs_n(nbars); fs_w(" today=" as *u8); fs_w(today); fs_w("\n" as *u8) 984 if nbars == 0 { fs_w("NO-BAR domain=" as *u8); fs_w(dom); fs_w(" -- no sotabar row, nothing to attest (a domain opts in by declaring its first bar)\n" as *u8); return 0 } 985 let rpath: *u8 = sys_mmap(FS_PATHCAP) 986 fs_cmp_path(rpath, dom, ".refs" as *u8) 987 let rflen: *i64 = sys_mmap(16) as *i64 988 let refs: *u8 = sys_read_file(rpath, rflen) 989 var refsn: i64 = 0 990 if (refs as i64) != 0 { refsn = rflen[0] } 991 let spos: *i64 = sys_mmap(8 * FS_MAXP) as *i64 992 var ndated: i64 = 0 993 var s0: i64 = 0 994 while s0 < sn { 995 let sle0: i64 = fs_eol(sb, sn, s0) 996 if fs_is_row(sb, s0, sle0) == 1 { if fs_pipes(sb, s0, sle0, spos) >= FS_DATED_PIPES { if fs_streq(sb, s0, spos[0], "src" as *u8) == 1 { ndated = ndated + 1 } } } 997 s0 = sle0 + 1 998 } 999 fs_w("DATED-SOURCES " as *u8); fs_n(ndated); fs_w(" (source rows carrying a date spec; the undated ones are scan-only)\n" as *u8) 1000 let wl: *u8 = sys_mmap((nbars + 1) * (ndated + 1) * FS_LINECAP + FS_TXTCAP) 1001 var wp: i64 = 0 1002 sys_mkdir("/tmp/nx_frontier_scan" as *u8, FS_DIRMODE) 1003 let tmpout: *u8 = "/tmp/nx_frontier_scan/attest_fetch.out" as *u8 1004 let url: *u8 = sys_mmap(FS_URLCAP) 1005 let qbuf: *u8 = sys_mmap(FS_URLCAP) 1006 let kind: *u8 = sys_mmap(FS_TXTCAP) 1007 let idlm: *u8 = sys_mmap(FS_TXTCAP) 1008 let topen: *u8 = sys_mmap(FS_TXTCAP) 1009 let tclos: *u8 = sys_mmap(FS_TXTCAP) 1010 let uopen: *u8 = sys_mmap(FS_TXTCAP) 1011 let uclos: *u8 = sys_mmap(FS_TXTCAP) 1012 let join: *u8 = sys_mmap(FS_TXTCAP) 1013 let dopen: *u8 = sys_mmap(FS_TXTCAP) 1014 let dclos: *u8 = sys_mmap(FS_TXTCAP) 1015 let akind: *u8 = sys_mmap(FS_TXTCAP) 1016 let refkey: *u8 = sys_mmap(FS_TXTCAP) 1017 let tok: *u8 = sys_mmap(FS_TXTCAP) 1018 let note: *u8 = sys_mmap(FS_LINECAP) 1019 let savepath: *u8 = sys_mmap(FS_PATHCAP) 1020 let olen: *i64 = sys_mmap(16) as *i64 1021 let rlen: *i64 = sys_mmap(16) as *i64 1022 let cnt: *i64 = sys_mmap(8 * 8) as *i64 1023 let fo: *i64 = sys_mmap(16) as *i64 1024 let uo: *i64 = sys_mmap(16) as *i64 1025 let ymb: *u8 = sys_mmap(FS_YMBUF) 1026 var p: i64 = 0 1027 while p < pn { 1028 let e: i64 = bf_line_end(pb, pn, p) 1029 if bf_line_starts(pb, p, e, BF_BAR_TAG) == 1 { 1030 tot[FS_ATT_C_BARS] = tot[FS_ATT_C_BARS] + 1 1031 let idl: i64 = bf_field(pb, p, e, BF_F_BAR_ID, fo) 1032 let ido: i64 = fo[0] 1033 let yml: i64 = bf_field(pb, p, e, BF_F_BAR_YM, fo) 1034 let ymo: i64 = fo[0] 1035 let sjl: i64 = bf_field(pb, p, e, BF_F_BAR_SUBJECT, fo) 1036 let sjo: i64 = fo[0] 1037 let rkl: i64 = bf_field(pb, p, e, BF_F_BAR_REF, fo) 1038 let rko: i64 = fo[0] 1039 var bar_ym: i64 = 0 - 1 1040 if yml > 0 { bar_ym = fs_ym_at(pb, ymo, ymo + yml) } 1041 var rk: i64 = 0 1042 if rkl > 0 { rk = fs_catn(refkey, 0, pb, rko, rko + rkl) } 1043 refkey[rk] = 0 as u8 1044 fs_w("BAR " as *u8); fs_wn(pb, ido, idl); fs_w(" month=" as *u8); fs_wn(pb, ymo, yml) 1045 fs_w(" ref=" as *u8); fs_w(refkey); fs_w(" subject=" as *u8); fs_wn(pb, sjo, sjl); fs_w("\n" as *u8) 1046 if bar_ym < 0 { fs_w(" ATTEST-UNATTESTABLE reason=bar-month-malformed\n" as *u8); tot[FS_ATT_C_UNATTESTABLE] = tot[FS_ATT_C_UNATTESTABLE] + 1 } else { 1047 // ---- ATTEST LEG: the listing the bar itself cites ---- 1048 akind[0] = 0 as u8 1049 let ul: i64 = fs_ref_url(refs, refsn, refkey, rk, uo) 1050 if ul <= 0 { fs_w(" ATTEST-UNATTESTABLE reason=ref-not-in-refs ref=" as *u8); fs_w(refkey); fs_w("\n" as *u8); tot[FS_ATT_C_UNATTESTABLE] = tot[FS_ATT_C_UNATTESTABLE] + 1 } else { 1051 let un: i64 = fs_catn(url, 0, refs, uo[0], uo[0] + ul) 1052 url[un] = 0 as u8 1053 var srow: i64 = 0 - 1 1054 var si: i64 = 0 1055 while si < sn { 1056 let sle: i64 = fs_eol(sb, sn, si) 1057 if fs_is_row(sb, si, sle) == 1 { if fs_pipes(sb, si, sle, spos) >= FS_DATED_PIPES { if fs_streq(sb, si, spos[0], "src" as *u8) == 1 { 1058 var pe: i64 = fs_find(sb, spos[2], spos[1] + 1, "{q}" as *u8) 1059 if pe < 0 { pe = spos[2] } 1060 let pl: i64 = pe - (spos[1] + 1) 1061 if pl > 0 { if pl <= un { 1062 var m: i64 = 1 1063 var j: i64 = 0 1064 while j < pl { if url[j] != sb[spos[1] + 1 + j] { m = 0; j = pl } else { j = j + 1 } } 1065 if m == 1 { if srow < 0 { srow = si } } 1066 } } 1067 } } } 1068 si = sle + 1 1069 } 1070 if srow < 0 { fs_w(" ATTEST-UNATTESTABLE reason=no-dated-source-row-knows-this-listing url=" as *u8); fs_w(url); fs_w("\n" as *u8); tot[FS_ATT_C_UNATTESTABLE] = tot[FS_ATT_C_UNATTESTABLE] + 1 } else { 1071 let sle2: i64 = fs_eol(sb, sn, srow) 1072 fs_pipes(sb, srow, sle2, spos) 1073 fs_src_fields(sb, spos, sle2, kind, idlm, topen, tclos, uopen, uclos, join, dopen, dclos) 1074 let akl: i64 = fs_cat(akind, 0, kind) 1075 akind[akl] = 0 as u8 1076 tot[FS_ATT_C_FETCHES] = tot[FS_ATT_C_FETCHES] + 1 1077 let got: i64 = fs_fetch(url, tmpout, savepath, olen) 1078 if got <= 0 { fs_w(" ATTEST-UNATTESTABLE reason=source-unreachable kind=" as *u8); fs_w(kind); fs_w(" (UNOBSERVABLE, not zero)\n" as *u8); tot[FS_ATT_C_UNATTESTABLE] = tot[FS_ATT_C_UNATTESTABLE] + 1 } else { 1079 let rb: *u8 = sys_read_file(savepath, rlen) 1080 if (rb as i64) == 0 { fs_w(" ATTEST-UNATTESTABLE reason=mirror-unreadable\n" as *u8); tot[FS_ATT_C_UNATTESTABLE] = tot[FS_ATT_C_UNATTESTABLE] + 1 } else { 1081 let rn: i64 = rlen[0] 1082 let fixed: i64 = fs_fixed_month(dopen) 1083 let newest: i64 = fs_newest_month(rb, rn, idlm, dopen, dclos, fixed, max_items, pb, 0, 0, min_token, tok, cnt) 1084 if newest < 0 { fs_w(" ATTEST-UNATTESTABLE reason=no-dated-item kind=" as *u8); fs_w(kind); fs_w(" items=" as *u8); fs_n(cnt[0]); fs_w("\n" as *u8); tot[FS_ATT_C_UNATTESTABLE] = tot[FS_ATT_C_UNATTESTABLE] + 1 } else { 1085 fs_w(" ATTEST kind=" as *u8); fs_w(kind); fs_w(" items=" as *u8); fs_n(cnt[0]); fs_w(" dated=" as *u8); fs_n(cnt[1]) 1086 fs_w(" newest=" as *u8); fs_w_ym(ymb, newest); fs_w(" bar=" as *u8); fs_w_ym(ymb, bar_ym) 1087 if newest > bar_ym { fs_w(" verdict=NEWER (the listing moved past the bar -- nx_barfresh reads STALE until a seat re-adjudicates the sotabar row)" as *u8); tot[FS_ATT_C_STALE] = tot[FS_ATT_C_STALE] + 1 } else { if newest == bar_ym { fs_w(" verdict=SAME" as *u8) } else { fs_w(" verdict=OLDER (the listing carries nothing newer than the bar)" as *u8) } } 1088 fs_w("\n" as *u8) 1089 var np9: i64 = fs_cat(note, 0, "attested by nx_frontier_scan attest: " as *u8) 1090 np9 = fs_catn_num(note, np9, cnt[0]); np9 = fs_cat(note, np9, " items read, " as *u8) 1091 np9 = fs_catn_num(note, np9, cnt[1]); np9 = fs_cat(note, np9, " dated, newest item " as *u8) 1092 if cnt[4] > cnt[3] { np9 = fs_catn(note, np9, rb, cnt[3], cnt[4]) } else { np9 = fs_cat(note, np9, "(fixed month)" as *u8) } 1093 np9 = fs_cat(note, np9, ", mirror " as *u8); np9 = fs_cat(note, np9, savepath) 1094 note[np9] = 0 as u8 1095 let arc: i64 = fs_attest_row(path, refkey, today, newest, note) 1096 if arc == 1 { fs_w(" BARSCAN-APPENDED plan=" as *u8); fs_w(path); fs_w("\n" as *u8); tot[FS_ATT_C_APPENDED] = tot[FS_ATT_C_APPENDED] + 1 } else { if arc == 0 { fs_w(" BARSCAN-ALREADY-PRESENT (same date and ref: idempotent)\n" as *u8); tot[FS_ATT_C_ALREADY] = tot[FS_ATT_C_ALREADY] + 1 } else { fs_w(" BARSCAN-UNWRITABLE plan=" as *u8); fs_w(path); fs_w("\n" as *u8); tot[FS_ATT_C_UNATTESTABLE] = tot[FS_ATT_C_UNATTESTABLE] + 1 } } 1097 } 1098 } 1099 } 1100 } 1101 } 1102 // ---- FAN-OUT LEG: every OTHER dated source, asked the bar's own subject ---- 1103 var fi: i64 = 0 1104 while fi < sn { 1105 let fle: i64 = fs_eol(sb, sn, fi) 1106 if fs_is_row(sb, fi, fle) == 1 { if fs_pipes(sb, fi, fle, spos) >= FS_DATED_PIPES { if fs_streq(sb, fi, spos[0], "src" as *u8) == 1 { 1107 fs_src_fields(sb, spos, fle, kind, idlm, topen, tclos, uopen, uclos, join, dopen, dclos) 1108 if fs_streq(kind, 0, fs_slen(kind), akind) == 0 { 1109 fs_seed_q(qbuf, pb, sjo, sjo + sjl, FS_URLCAP, seed_tokens, min_token, join) 1110 let had: i64 = fs_build_url(url, sb, spos[1] + 1, spos[2], qbuf) 1111 tot[FS_ATT_C_FETCHES] = tot[FS_ATT_C_FETCHES] + 1 1112 let fgot: i64 = fs_fetch(url, tmpout, savepath, olen) 1113 if fgot <= 0 { fs_w(" FANOUT kind=" as *u8); fs_w(kind); fs_w(" verdict=UNREACHABLE (UNOBSERVABLE, not zero) url=" as *u8); fs_w(url); fs_w("\n" as *u8) } else { 1114 let fb: *u8 = sys_read_file(savepath, rlen) 1115 if (fb as i64) == 0 { fs_w(" FANOUT kind=" as *u8); fs_w(kind); fs_w(" verdict=MIRROR-UNREADABLE\n" as *u8) } else { 1116 let fn9: i64 = rlen[0] 1117 let ffix: i64 = fs_fixed_month(dopen) 1118 var subjn: i64 = 0 1119 if had == 0 { subjn = sjl } 1120 let fnew: i64 = fs_newest_month(fb, fn9, idlm, dopen, dclos, ffix, max_items, pb, sjo, subjn, min_token, tok, cnt) 1121 fs_w(" FANOUT kind=" as *u8); fs_w(kind); fs_w(" q=" as *u8) 1122 if had == 0 { fs_w("(static listing, filtered by the subject tokens)" as *u8) } else { fs_w(qbuf) } 1123 fs_w(" items=" as *u8); fs_n(cnt[0]); fs_w(" dated=" as *u8); fs_n(cnt[1]); fs_w(" newest=" as *u8) 1124 if fnew < 0 { fs_w("NONE verdict=UNDATED\n" as *u8) } else { 1125 fs_w_ym(ymb, fnew); fs_w(" vs_bar=" as *u8); fs_w_ym(ymb, bar_ym) 1126 if fnew > bar_ym { 1127 fs_w(" verdict=NEWER\n" as *u8) 1128 tot[FS_ATT_C_NEWER] = tot[FS_ATT_C_NEWER] + 1 1129 let bit: i64 = cnt[2] 1130 if bit >= 0 { 1131 let bie: i64 = fs_item_end(fb, fn9, bit, idlm) 1132 let tl9: i64 = fs_item_field(fb, bit, bie, topen, tclos, fo) 1133 let to9: i64 = fo[0] 1134 let ul9: i64 = fs_item_field(fb, bit, bie, uopen, uclos, fo) 1135 let uo9: i64 = fo[0] 1136 fs_w(" newest: " as *u8) 1137 if tl9 > 0 { fs_wn(fb, to9, tl9) } else { fs_w("(untitled)" as *u8) } 1138 fs_w(" | " as *u8) 1139 if ul9 > 0 { fs_wn(fb, uo9, ul9) } else { fs_w("(no url)" as *u8) } 1140 fs_w(" | mirror " as *u8); fs_w(savepath); fs_w("\n" as *u8) 1141 wp = fs_cat(wl, wp, "NEWER|" as *u8); wp = fs_cat(wl, wp, dbase); wp = fs_cat(wl, wp, "|" as *u8) 1142 wp = fs_catn(wl, wp, pb, ido, ido + idl); wp = fs_cat(wl, wp, "|" as *u8) 1143 wp = fs_cat(wl, wp, kind); wp = fs_cat(wl, wp, "|" as *u8) 1144 wp = bf_ym_write(wl, wp, fnew); wp = fs_cat(wl, wp, "|" as *u8) 1145 if tl9 > 0 { wp = fs_catn(wl, wp, fb, to9, to9 + tl9) } 1146 wp = fs_cat(wl, wp, "|" as *u8) 1147 if ul9 > 0 { wp = fs_catn(wl, wp, fb, uo9, uo9 + ul9) } 1148 wp = fs_cat(wl, wp, "|" as *u8); wp = fs_cat(wl, wp, savepath) 1149 wl[wp] = FS_NL as u8; wp = wp + 1 1150 } 1151 } else { if fnew == bar_ym { fs_w(" verdict=SAME\n" as *u8) } else { fs_w(" verdict=OLDER\n" as *u8) } } 1152 } 1153 } 1154 } 1155 } 1156 } } } 1157 fi = fle + 1 1158 } 1159 } 1160 } 1161 p = e + 1 1162 } 1163 if wp > 0 { 1164 let fld: *u8 = sys_mmap(FS_PATHCAP) 1165 var lp: i64 = 0 1166 if fs_has_slash(dom) == 1 { lp = fs_cat(fld, 0, "/tmp/nx_frontier_scan/frontier_attest_" as *u8) } else { lp = fs_cat(fld, 0, "knowledge/status/frontier_attest_" as *u8) } 1167 lp = fs_cat(fld, lp, dbase); lp = fs_cat(fld, lp, ".txt" as *u8); fld[lp] = 0 as u8 1168 let wrote: i64 = dp_writefile(fld, wl, wp) 1169 fs_w("WORKLIST path=" as *u8); fs_w(fld); fs_w(" bytes=" as *u8); fs_n(wp); fs_w(" wrote=" as *u8); fs_n(wrote); fs_w(" (NEWER rows a seat adjudicates into sotabar rows -- never admitted here)\n" as *u8) 1170 } 1171 return 0 1172} 1173 1174func main(argc: i64, argv: *i64) -> i64 { 1175 if argc < 3 { 1176 fs_w("usage: nx_frontier_scan seeds <domain>\n" as *u8) 1177 fs_w(" nx_frontier_scan attest <domain>|all [YYYY-MM-DD] re-earn every sotabar row's month: barscan rows + the fan-out\n" as *u8) 1178 fs_w(" nx_frontier_scan monthprobe <file> <item-delim> <date-open|month=YYYY-MM> <date-close> (offline)\n" as *u8) 1179 fs_w(" nx_frontier_scan attestfile <plan> <ref-key> <YYYY-MM-DD> <YYYY-MM> <note> (offline, idempotent)\n" as *u8) 1180 fs_w(" nx_frontier_scan deficit <domain>\n" as *u8) 1181 fs_w(" nx_frontier_scan scan <domain> [maxrows] [maxitems]\n" as *u8) 1182 fs_w(" nx_frontier_scan propose <domain> [maxrows] [maxitems]\n" as *u8) 1183 fs_w(" <domain> is a /compare domain name, OR a path prefix if it contains a slash -- e.g.\n" as *u8) 1184 fs_w(" /tmp/nx_frontier_scan_gate/fx reads /tmp/nx_frontier_scan_gate/fx.matrix and fx.refs,\n" as *u8) 1185 fs_w(" which is how a gate keeps its fixture out of the live board and how the replay harness\n" as *u8) 1186 fs_w(" reconstructs a historical domain without writing into knowledge/compare.\n" as *u8) 1187 fs_w(" the autonomous frontier-noticer: seeds from the domain's OWN data, outside pulled through\n" as *u8) 1188 fs_w(" nx_research_fetch, diffed against the board, PROPOSALS ONLY -- it never writes .matrix or\n" as *u8) 1189 fs_w(" .refs and never flips a watch cell.\n" as *u8) 1190 sys_exit(2); return 2 1191 } 1192 let verb: *u8 = argv[1] as *u8 1193 let dom: *u8 = argv[2] as *u8 1194 // dom BUILDS PATHS; dbase LABELS OUTPUT. Keeping them separate is what stops a fixture path leaking 1195 // into a plane id or a status filename. 1196 let dbase: *u8 = ((dom as i64) + fs_basename(dom)) as *u8 1197 let vlen: i64 = fs_slen(verb) 1198 1199 if fs_streq(verb, 0, vlen, "seeds" as *u8) == 1 { 1200 fs_w("=== nx_frontier_scan seeds " as *u8); fs_w(dom); fs_w(" ===\n" as *u8) 1201 if fs_emit_seeds(dom) < 0 { sys_exit(3); return 3 } 1202 sys_exit(0); return 0 1203 } 1204 1205 if fs_streq(verb, 0, vlen, "pairprobe" as *u8) == 1 { 1206 // OFFLINE EXTRACTOR PROBE (2026-08-20). The pairing rule -- every field belongs to its OWN item -- 1207 // is the one thing in this organ that can manufacture a fabricated citation, and until now it was 1208 // reachable ONLY through a live network fetch, which no gate may do. ★★★★★A RULE THAT CAN ONLY BE 1209 // EXERCISED OVER THE NETWORK IS A RULE NO GATE CAN HOLD. This verb runs the SAME fs_item_end bound 1210 // over a file, so the rule is testable hermetically and a mutant that drops the bound is killable. 1211 if argc < 8 { 1212 fs_w("usage: nx_frontier_scan pairprobe <file> <item-delim> <title-open> <title-close> <url-open> <url-close>\n" as *u8) 1213 sys_exit(2); return 2 1214 } 1215 let plen: *i64 = sys_mmap(16) as *i64 1216 let pb: *u8 = sys_read_file(dom, plen) 1217 if (pb as i64) == 0 { 1218 fs_w("PAIRPROBE REFUSED verdict=RED reason=unreadable file=" as *u8); fs_w(dom); fs_w("\n" as *u8) 1219 sys_exit(1); return 1 1220 } 1221 let pn: i64 = plen[0] 1222 let pidlm: *u8 = argv[3] as *u8 1223 let ptop: *u8 = argv[4] as *u8 1224 let ptcl: *u8 = argv[5] as *u8 1225 let puop: *u8 = argv[6] as *u8 1226 let pucl: *u8 = argv[7] as *u8 1227 fs_w("=== nx_frontier_scan pairprobe " as *u8); fs_w(dom); fs_w(" ===\n" as *u8) 1228 var pcur: i64 = 0 1229 var pitems: i64 = 0 1230 var ppaired: i64 = 0 1231 var punpaired: i64 = 0 1232 var pgo: i64 = 1 1233 while pgo == 1 { 1234 let pit: i64 = fs_find(pb, pn, pcur, pidlm) 1235 if pit < 0 { pgo = 0 } else { 1236 let pie: i64 = fs_item_end(pb, pn, pit, pidlm) 1237 pcur = pit + fs_slen(pidlm) 1238 pitems = pitems + 1 1239 let pts: i64 = fs_find(pb, pie, pit, ptop) 1240 let pus: i64 = fs_find(pb, pie, pit, puop) 1241 var pok: i64 = 1 1242 if pts < 0 { pok = 0 } 1243 if pus < 0 { pok = 0 } 1244 var pta: i64 = 0 1245 var pte: i64 = 0 1246 var pua: i64 = 0 1247 var pue: i64 = 0 1248 if pok == 1 { 1249 pta = pts + fs_slen(ptop) 1250 pte = fs_find(pb, pie, pta, ptcl) 1251 pua = pus + fs_slen(puop) 1252 pue = fs_find(pb, pie, pua, pucl) 1253 if pte < 0 { pok = 0 } 1254 if pue < 0 { pok = 0 } 1255 } 1256 if pok == 1 { 1257 ppaired = ppaired + 1 1258 var pin: i64 = 0 1259 if pua >= pit { if pue <= pie { pin = 1 } } 1260 fs_w("ITEM n=" as *u8); fs_n(pitems) 1261 fs_w(" span=" as *u8); fs_n(pit); fs_w("-" as *u8); fs_n(pie) 1262 fs_w(" url_in_own_item=" as *u8); fs_n(pin) 1263 fs_w(" title=" as *u8); fs_wn(pb, pta, pte - pta) 1264 fs_w(" url=" as *u8); fs_wn(pb, pua, pue - pua) 1265 fs_w("\n" as *u8) 1266 } else { 1267 punpaired = punpaired + 1 1268 fs_w("ITEM n=" as *u8); fs_n(pitems) 1269 fs_w(" span=" as *u8); fs_n(pit); fs_w("-" as *u8); fs_n(pie) 1270 fs_w(" UNPAIRED -- a field is absent from THIS item and is NOT borrowed from the next\n" as *u8) 1271 } 1272 } 1273 } 1274 fs_w("PAIRPROBE items=" as *u8); fs_n(pitems) 1275 fs_w(" paired=" as *u8); fs_n(ppaired) 1276 fs_w(" unpaired=" as *u8); fs_n(punpaired) 1277 fs_w(" bound=item-extent (paired plus unpaired equals items -- and every url above lies inside its own item, which is the invariant this verb exists to state out loud)\n" as *u8) 1278 sys_exit(0); return 0 1279 } 1280 1281 if fs_streq(verb, 0, vlen, "monthprobe" as *u8) == 1 { 1282 // OFFLINE MONTH READER (2026-09-06): the newest-month rule is the one thing that can make a bar read 1283 // ATTESTED, so it must be testable hermetically -- a gate may never fetch the live web on a beat. 1284 if argc < 6 { 1285 fs_w("usage: nx_frontier_scan monthprobe <file> <item-delim> <date-open|month=YYYY-MM> <date-close>\n" as *u8) 1286 sys_exit(2); return 2 1287 } 1288 let mlen9: *i64 = sys_mmap(16) as *i64 1289 let mb9: *u8 = sys_read_file(dom, mlen9) 1290 if (mb9 as i64) == 0 { fs_w("MONTHPROBE REFUSED reason=unreadable file=" as *u8); fs_w(dom); fs_w("\n" as *u8); sys_exit(1); return 1 } 1291 let cnt9: *i64 = sys_mmap(8 * 8) as *i64 1292 let tok9: *u8 = sys_mmap(FS_TXTCAP) 1293 let ymb9: *u8 = sys_mmap(FS_YMBUF) 1294 let dop9: *u8 = argv[4] as *u8 1295 // every item counts: the bound is the file's own length (an item is at least one byte), so nothing is capped in silence 1296 let nw9: i64 = fs_newest_month(mb9, mlen9[0], argv[3] as *u8, dop9, argv[5] as *u8, fs_fixed_month(dop9), mlen9[0], mb9, 0, 0, 1, tok9, cnt9) 1297 fs_w("MONTHPROBE items=" as *u8); fs_n(cnt9[0]); fs_w(" dated=" as *u8); fs_n(cnt9[1]); fs_w(" newest=" as *u8) 1298 if nw9 < 0 { fs_w("NONE (no item carried a date the reader could parse -- UNDATED abstains, it never reads as a month)\n" as *u8) } else { fs_w_ym(ymb9, nw9); fs_w("\n" as *u8) } 1299 sys_exit(0); return 0 1300 } 1301 1302 if fs_streq(verb, 0, vlen, "attestfile" as *u8) == 1 { 1303 // OFFLINE ATTESTATION WRITER: the idempotence rule (one barscan row per date and ref) held to a fixture plan. 1304 if argc < 7 { 1305 fs_w("usage: nx_frontier_scan attestfile <plan> <ref-key> <YYYY-MM-DD> <YYYY-MM> <note>\n" as *u8) 1306 sys_exit(2); return 2 1307 } 1308 let aym9: i64 = fs_ym_at(argv[5] as *u8, 0, fs_slen(argv[5] as *u8)) 1309 if aym9 < 0 { fs_w("ATTESTFILE REFUSED reason=month-malformed month=" as *u8); fs_w(argv[5] as *u8); fs_w("\n" as *u8); sys_exit(1); return 1 } 1310 let arc9: i64 = fs_attest_row(dom, argv[3] as *u8, argv[4] as *u8, aym9, argv[6] as *u8) 1311 fs_w("ATTESTFILE rc=" as *u8); fs_n(arc9); fs_w(" (1=appended 0=already-present -1=unwritable) plan=" as *u8); fs_w(dom); fs_w("\n" as *u8) 1312 sys_exit(0); return 0 1313 } 1314 1315 if fs_streq(verb, 0, vlen, "attest" as *u8) == 1 { 1316 let aclen: *i64 = sys_mmap(16) as *i64 1317 let acb: *u8 = sys_read_file("knowledge/frontier_scan.conf" as *u8, aclen) 1318 if (acb as i64) == 0 { fs_w("ATTEST REFUSED verdict=RED reason=missing-conf path=knowledge/frontier_scan.conf\n" as *u8); sys_exit(1); return 1 } 1319 let acn: i64 = aclen[0] 1320 let a_items: i64 = fs_conf_get(acb, acn, "max_items" as *u8) 1321 let a_mintok: i64 = fs_conf_get(acb, acn, "min_token" as *u8) 1322 let a_seedtok: i64 = fs_conf_get(acb, acn, "seed_tokens" as *u8) 1323 if a_items < 0 { fs_w("ATTEST REFUSED reason=conf-missing-key key=max_items\n" as *u8); sys_exit(1); return 1 } 1324 if a_mintok < 0 { fs_w("ATTEST REFUSED reason=conf-missing-key key=min_token\n" as *u8); sys_exit(1); return 1 } 1325 if a_seedtok < 0 { fs_w("ATTEST REFUSED reason=conf-missing-key key=seed_tokens\n" as *u8); sys_exit(1); return 1 } 1326 let slen9: *i64 = sys_mmap(16) as *i64 1327 let sb9: *u8 = sys_read_file("knowledge/frontier_sources.conf" as *u8, slen9) 1328 if (sb9 as i64) == 0 { fs_w("ATTEST REFUSED verdict=RED reason=missing-conf path=knowledge/frontier_sources.conf\n" as *u8); sys_exit(1); return 1 } 1329 let today9: *u8 = sys_mmap(FS_TODAYBUF) 1330 if argc >= 4 { let tl9: i64 = fs_cat(today9, 0, argv[3] as *u8); today9[tl9] = 0 as u8 } else { fs_today(today9) } 1331 let tot9: *i64 = sys_mmap(8 * FS_ATT_C_N) as *i64 1332 var ti9: i64 = 0 1333 while ti9 < FS_ATT_C_N { tot9[ti9] = 0; ti9 = ti9 + 1 } 1334 var doms9: i64 = 0 1335 if fs_streq(dom, 0, fs_slen(dom), "all" as *u8) == 1 { 1336 let llen9: *i64 = sys_mmap(16) as *i64 1337 let lb9: *u8 = sys_read_file("buildroot/knowledge/compare/regen.list" as *u8, llen9) 1338 if (lb9 as i64) == 0 { fs_w("ATTEST REFUSED reason=no-regen-list path=buildroot/knowledge/compare/regen.list\n" as *u8); sys_exit(1); return 1 } 1339 let ln9: i64 = llen9[0] 1340 let dbuf9: *u8 = sys_mmap(FS_TXTCAP) 1341 var li9: i64 = 0 1342 while li9 < ln9 { 1343 let le9: i64 = fs_eol(lb9, ln9, li9) 1344 if fs_is_row(lb9, li9, le9) == 1 { if le9 > li9 { 1345 var dl9: i64 = fs_catn(dbuf9, 0, lb9, li9, le9) 1346 // a list edited on another host carries CR before LF; a domain name never does 1347 if dl9 > 0 { if dbuf9[dl9 - 1] == (FS_CR as u8) { dl9 = dl9 - 1 } } 1348 dbuf9[dl9] = 0 as u8 1349 doms9 = doms9 + 1 1350 fs_attest_domain(dbuf9, dbuf9, sb9, slen9[0], today9, a_items, a_mintok, a_seedtok, tot9) 1351 } } 1352 li9 = le9 + 1 1353 } 1354 } else { doms9 = 1; fs_attest_domain(dom, dbase, sb9, slen9[0], today9, a_items, a_mintok, a_seedtok, tot9) } 1355 fs_w("ATTEST-DONE domains=" as *u8); fs_n(doms9) 1356 fs_w(" bars=" as *u8); fs_n(tot9[FS_ATT_C_BARS]) 1357 fs_w(" appended=" as *u8); fs_n(tot9[FS_ATT_C_APPENDED]) 1358 fs_w(" already=" as *u8); fs_n(tot9[FS_ATT_C_ALREADY]) 1359 fs_w(" unattestable=" as *u8); fs_n(tot9[FS_ATT_C_UNATTESTABLE]) 1360 fs_w(" (appended plus already plus unattestable equals bars)" as *u8) 1361 fs_w(" fetches=" as *u8); fs_n(tot9[FS_ATT_C_FETCHES]) 1362 fs_w(" newer_sources=" as *u8); fs_n(tot9[FS_ATT_C_NEWER]) 1363 fs_w(" stale_bars=" as *u8); fs_n(tot9[FS_ATT_C_STALE]) 1364 var vb9: i64 = 0 1365 if tot9[FS_ATT_C_STALE] > 0 { vb9 = 1 } 1366 if vb9 == 1 { fs_w(" verdict=STALE-BARS (a cited listing moved past its bar: re-adjudicate the sotabar row)\n" as *u8) } else { fs_w(" verdict=ATTESTED\n" as *u8) } 1367 sys_exit(vb9); return vb9 1368 } 1369 1370 let clen: *i64 = sys_mmap(16) as *i64 1371 let cb: *u8 = sys_read_file("knowledge/frontier_scan.conf" as *u8, clen) 1372 if (cb as i64) == 0 { 1373 fs_w("FRONTIER-SCAN REFUSED verdict=RED reason=missing-conf path=knowledge/frontier_scan.conf" as *u8) 1374 fs_w(" fix=seed the thresholds file with rows lead_code, cover_permil, min_token, max_rows, max_items -- each row carrying its derivation\n" as *u8) 1375 sys_exit(1); return 1 1376 } 1377 let cn: i64 = clen[0] 1378 let lead_code: i64 = fs_conf_get(cb, cn, "lead_code" as *u8) 1379 let cover_permil: i64 = fs_conf_get(cb, cn, "cover_permil" as *u8) 1380 let min_token: i64 = fs_conf_get(cb, cn, "min_token" as *u8) 1381 var max_rows: i64 = fs_conf_get(cb, cn, "max_rows" as *u8) 1382 var max_items: i64 = fs_conf_get(cb, cn, "max_items" as *u8) 1383 let seed_tokens: i64 = fs_conf_get(cb, cn, "seed_tokens" as *u8) 1384 var bad: i64 = 0 1385 if seed_tokens < 0 { fs_w("FRONTIER-SCAN REFUSED reason=conf-missing-key key=seed_tokens\n" as *u8); bad = 1 } 1386 if lead_code < 0 { fs_w("FRONTIER-SCAN REFUSED reason=conf-missing-key key=lead_code\n" as *u8); bad = 1 } 1387 if cover_permil < 0 { fs_w("FRONTIER-SCAN REFUSED reason=conf-missing-key key=cover_permil\n" as *u8); bad = 1 } 1388 if min_token < 0 { fs_w("FRONTIER-SCAN REFUSED reason=conf-missing-key key=min_token\n" as *u8); bad = 1 } 1389 if max_rows < 0 { fs_w("FRONTIER-SCAN REFUSED reason=conf-missing-key key=max_rows\n" as *u8); bad = 1 } 1390 if max_items < 0 { fs_w("FRONTIER-SCAN REFUSED reason=conf-missing-key key=max_items\n" as *u8); bad = 1 } 1391 if bad == 1 { sys_exit(1); return 1 } 1392 if argc >= 4 { let v: i64 = fs_atoi(argv[3] as *u8); if v > 0 { max_rows = v } } 1393 if argc >= 5 { let v2: i64 = fs_atoi(argv[4] as *u8); if v2 > 0 { max_items = v2 } } 1394 1395 let path: *u8 = sys_mmap(FS_PATHCAP) 1396 fs_cmp_path(path, dom, ".matrix" as *u8) 1397 let mlen: *i64 = sys_mmap(16) as *i64 1398 let mb: *u8 = sys_read_file(path, mlen) 1399 if (mb as i64) == 0 { 1400 fs_w("FRONTIER-SCAN REFUSED verdict=RED reason=no-matrix path=" as *u8); fs_w(path); fs_w("\n" as *u8) 1401 sys_exit(3); return 3 1402 } 1403 let mn: i64 = mlen[0] 1404 1405 fs_w("=== nx_frontier_scan " as *u8); fs_w(verb); fs_w(" " as *u8); fs_w(dom); fs_w(" ===\n" as *u8) 1406 fs_w("CONF lead_code=" as *u8); fs_n(lead_code) 1407 fs_w(" cover_permil=" as *u8); fs_n(cover_permil) 1408 fs_w(" min_token=" as *u8); fs_n(min_token) 1409 fs_w(" max_rows=" as *u8); fs_n(max_rows) 1410 fs_w(" max_items=" as *u8); fs_n(max_items) 1411 fs_w(" seed_tokens=" as *u8); fs_n(seed_tokens) 1412 fs_w(" props_per_row=" as *u8); fs_n(FS_PROPS_PER_ROW); fs_w("\n" as *u8) 1413 1414 let rowa: *i64 = sys_mmap(8 * FS_MAXROWS) as *i64 1415 let rowb: *i64 = sys_mmap(8 * FS_MAXROWS) as *i64 1416 let score: *i64 = sys_mmap(8 * FS_MAXROWS) as *i64 1417 let nd: i64 = fs_deficit(mb, mn, lead_code, rowa, rowb, score, 1) 1418 1419 if fs_streq(verb, 0, vlen, "deficit" as *u8) == 1 { 1420 fs_w("DEFICIT-ROWS=" as *u8); fs_n(nd); fs_w("\n" as *u8) 1421 sys_exit(0); return 0 1422 } 1423 1424 var filing: i64 = 0 1425 if fs_streq(verb, 0, vlen, "propose" as *u8) == 1 { filing = 1 } 1426 1427 if nd == 0 { 1428 // THE POSITIVE CONTROL PATH, and it is why this organ is not a guard that refuses everything. 1429 // A domain where no rival leads a row we do not exceed yields ZERO proposals and ZERO outbound 1430 // fetches -- the input that MUST come back empty, answered without touching the network. 1431 fs_w("NO-DEFICIT domain=" as *u8); fs_w(dom) 1432 fs_w(" -- no row where a rival leads and we do not exceed; nothing to research\n" as *u8) 1433 fs_w("SCAN-DONE domain=" as *u8); fs_w(dom) 1434 fs_w(" deficit_rows=0 rows_scanned=0 fetches=0 PROPOSALS=0\n" as *u8) 1435 sys_exit(0); return 0 1436 } 1437 1438 // ---- the corpus we diff against: this domain's own labels, row notes and citation prose ---- 1439 fs_cmp_path(path, dom, ".refs" as *u8) 1440 let rflen: *i64 = sys_mmap(16) as *i64 1441 let refs: *u8 = sys_read_file(path, rflen) 1442 var refsn: i64 = 0 1443 if (refs as i64) != 0 { refsn = rflen[0] } 1444 // sized FROM THE INPUT, so there is no ceiling to guess and no silent truncation to hide. 1445 let corp: *u8 = sys_mmap(mn + refsn + FS_TXTCAP) 1446 var corpn: i64 = 0 1447 let cpos: *i64 = sys_mmap(8 * FS_MAXP) as *i64 1448 var ci: i64 = 0 1449 while ci < mn { 1450 let cle: i64 = fs_eol(mb, mn, ci) 1451 if fs_is_row(mb, ci, cle) == 1 { 1452 let cnp: i64 = fs_pipes(mb, ci, cle, cpos) 1453 if cnp >= 1 { 1454 corpn = fs_catn(corp, corpn, mb, ci, cpos[0]) 1455 corp[corpn] = FS_SPACE as u8; corpn = corpn + 1 1456 if cnp >= 8 { 1457 corpn = fs_catn(corp, corpn, mb, cpos[7] + 1, cle) 1458 corp[corpn] = FS_SPACE as u8; corpn = corpn + 1 1459 } 1460 } 1461 } 1462 ci = cle + 1 1463 } 1464 if refsn > 0 { corpn = fs_catn(corp, corpn, refs, 0, refsn) } 1465 fs_w("BOARD-CORPUS bytes=" as *u8); fs_n(corpn) 1466 fs_w(" refs_bytes=" as *u8); fs_n(refsn); fs_w("\n" as *u8) 1467 1468 sys_mkdir("/tmp/nx_frontier_scan" as *u8, FS_DIRMODE) 1469 1470 let slen: *i64 = sys_mmap(16) as *i64 1471 let sb: *u8 = sys_read_file("knowledge/frontier_sources.conf" as *u8, slen) 1472 if (sb as i64) == 0 { 1473 fs_w("FRONTIER-SCAN REFUSED verdict=RED reason=missing-conf path=knowledge/frontier_sources.conf" as *u8) 1474 fs_w(" fix=seed source rows src|<kind>|<url-template-with-brace-q>|<item>|<title-open>|<title-close>|<url-open>|<url-close>\n" as *u8) 1475 sys_exit(1); return 1 1476 } 1477 let sn: i64 = slen[0] 1478 // count the sources FIRST so the worklist buffer is derived, not guessed. 1479 let spos: *i64 = sys_mmap(8 * FS_MAXP) as *i64 1480 var nsrc: i64 = 0 1481 var sc0: i64 = 0 1482 while sc0 < sn { 1483 let sle0: i64 = fs_eol(sb, sn, sc0) 1484 if fs_is_row(sb, sc0, sle0) == 1 { 1485 let np0: i64 = fs_pipes(sb, sc0, sle0, spos) 1486 if np0 >= 8 { if fs_streq(sb, sc0, spos[0], "src" as *u8) == 1 { nsrc = nsrc + 1 } } 1487 } 1488 sc0 = sle0 + 1 1489 } 1490 if nsrc == 0 { 1491 fs_w("FRONTIER-SCAN REFUSED verdict=RED reason=no-src-rows path=knowledge/frontier_sources.conf\n" as *u8) 1492 sys_exit(1); return 1 1493 } 1494 if max_rows > nd { max_rows = nd } 1495 let wl: *u8 = sys_mmap(max_rows * nsrc * FS_PROPS_PER_ROW * FS_LINECAP + FS_TXTCAP) 1496 let wlout: *i64 = sys_mmap(16) as *i64 1497 wlout[0] = 0 1498 1499 // every buffer the inner loops need, allocated ONCE (never allocate in a hot loop) 1500 let qbuf: *u8 = sys_mmap(FS_URLCAP) 1501 let url: *u8 = sys_mmap(FS_URLCAP) 1502 let kind: *u8 = sys_mmap(FS_TXTCAP) 1503 let idlm: *u8 = sys_mmap(FS_TXTCAP) 1504 let topen: *u8 = sys_mmap(FS_TXTCAP) 1505 let tclos: *u8 = sys_mmap(FS_TXTCAP) 1506 let uopen: *u8 = sys_mmap(FS_TXTCAP) 1507 let uclos: *u8 = sys_mmap(FS_TXTCAP) 1508 let join: *u8 = sys_mmap(FS_TXTCAP) 1509 let tok: *u8 = sys_mmap(FS_TXTCAP) 1510 let savepath: *u8 = sys_mmap(FS_PATHCAP) 1511 let olen: *i64 = sys_mmap(16) as *i64 1512 let rlen: *i64 = sys_mmap(16) as *i64 1513 1514 var total_props: i64 = 0 1515 var fetches: i64 = 0 1516 var r: i64 = 0 1517 while r < max_rows { 1518 fs_w("ROW " as *u8); fs_n(r) 1519 fs_w(" score=" as *u8); fs_n(score[r]) 1520 fs_w(" " as *u8); fs_wn(mb, rowa[r], rowb[r] - rowa[r]); fs_w("\n" as *u8) 1521 var si: i64 = 0 1522 while si < sn { 1523 let sle: i64 = fs_eol(sb, sn, si) 1524 if fs_is_row(sb, si, sle) == 1 { 1525 let snp: i64 = fs_pipes(sb, si, sle, spos) 1526 if snp >= 8 { 1527 if fs_streq(sb, si, spos[0], "src" as *u8) == 1 { 1528 let kp: i64 = fs_catn(kind, 0, sb, spos[0] + 1, spos[1]); kind[kp] = 0 as u8 1529 // A STATIC LISTING (no {q} in its url: a conference index) cannot be asked a seed, so the scan would 1530 // propose its first max_items papers against EVERY deficit row regardless of subject. It is fan-out 1531 // only: `attest` reads it filtered by each bar's own subject tokens (2026-09-06). 1532 if fs_find(sb, spos[2], spos[1] + 1, "{q}" as *u8) < 0 { 1533 fs_w(" SOURCE-STATIC kind=" as *u8); fs_w(kind); fs_w(" -- no query slot, fan-out only (attest); skipped by scan\n" as *u8) 1534 } else { 1535 // THE JOIN IS THE SOURCE'S OWN OPERATOR, so the seed must be built INSIDE this loop. 1536 // arXiv's search_query needs +AND+ between terms or it matches the whole archive and 1537 // returns the newest submissions with HTTP 200; HN Algolia wants a plain +. 1538 // a DATED row (attest, 2026-09-06) carries two more fields after the join, so the join ends at the 1539 // ninth pipe when there is one; an eight-pipe row still runs to the end of its line 1540 var je: i64 = sle 1541 if snp >= 9 { je = spos[8] } 1542 let jp: i64 = fs_catn(join, 0, sb, spos[7] + 1, je); join[jp] = 0 as u8 1543 fs_seed_q(qbuf, mb, rowa[r], rowb[r], FS_URLCAP, seed_tokens, min_token, join) 1544 fs_w(" seed kind=" as *u8); fs_w(kind); fs_w(" q=" as *u8); fs_w(qbuf); fs_w("\n" as *u8) 1545 var up: i64 = 0 1546 var t: i64 = spos[1] + 1 1547 while t < spos[2] { 1548 var sub: i64 = 0 1549 if sb[t] == (FS_LBRACE as u8) { 1550 if fs_prefix(sb, t, spos[2], "{q}" as *u8) == 1 { sub = 1 } 1551 } 1552 if sub == 1 { up = fs_cat(url, up, qbuf); t = t + 3 } 1553 else { url[up] = sb[t]; up = up + 1; t = t + 1 } 1554 } 1555 url[up] = 0 as u8 1556 let q1: i64 = fs_catn(idlm, 0, sb, spos[2] + 1, spos[3]); idlm[q1] = 0 as u8 1557 let q2: i64 = fs_catn(topen, 0, sb, spos[3] + 1, spos[4]); topen[q2] = 0 as u8 1558 let q3: i64 = fs_catn(tclos, 0, sb, spos[4] + 1, spos[5]); tclos[q3] = 0 as u8 1559 let q4: i64 = fs_catn(uopen, 0, sb, spos[5] + 1, spos[6]); uopen[q4] = 0 as u8 1560 let q5: i64 = fs_catn(uclos, 0, sb, spos[6] + 1, spos[7]); uclos[q5] = 0 as u8 1561 fetches = fetches + 1 1562 let got: i64 = fs_scan_source(dbase, kind, url, idlm, topen, tclos, uopen, uclos, 1563 corp, corpn, refs, refsn, mb, rowa[r], rowb[r], 1564 max_items, cover_permil, min_token, 1565 wl, wlout, tok, savepath, olen, rlen) 1566 total_props = total_props + got 1567 } 1568 } 1569 } 1570 } 1571 si = sle + 1 1572 } 1573 r = r + 1 1574 } 1575 let wp: i64 = wlout[0] 1576 1577 fs_w("SCAN-DONE domain=" as *u8); fs_w(dom) 1578 fs_w(" deficit_rows=" as *u8); fs_n(nd) 1579 fs_w(" rows_scanned=" as *u8); fs_n(max_rows) 1580 fs_w(" sources=" as *u8); fs_n(nsrc) 1581 fs_w(" fetches=" as *u8); fs_n(fetches) 1582 fs_w(" PROPOSALS=" as *u8); fs_n(total_props); fs_w("\n" as *u8) 1583 1584 if filing == 1 { 1585 // FIXTURE MODE IS HERMETIC. A path-form domain writes its worklist and its plane rows under 1586 // /tmp, never into knowledge/status or the production frontierprop- plane. This is not tidiness: 1587 // A GATE MUST NOT SHARE ITS FIXTURE WITH A PRODUCTION BEAT, and the first cut of this organ had 1588 // its own gate filing fixture rows into the live plane and blocking on that plane's flock. 1589 var fixture: i64 = 0 1590 if fs_has_slash(dom) == 1 { fixture = 1 } 1591 let fld: *u8 = sys_mmap(FS_PATHCAP) 1592 let plane: *u8 = sys_mmap(FS_PATHCAP) 1593 var lp: i64 = 0 1594 var pp: i64 = 0 1595 if fixture == 1 { 1596 lp = fs_cat(fld, 0, "/tmp/nx_frontier_scan/frontier_proposals_" as *u8) 1597 pp = fs_cat(plane, 0, "/tmp/nx_frontier_scan/fxprop-" as *u8) 1598 fs_w("FIXTURE-MODE worklist and plane are redirected under /tmp -- no production surface is touched\n" as *u8) 1599 } else { 1600 // the worklist is named for the domain's BASENAME, so a real domain always lands on its own 1601 // stable, regenerated-each-run file. 1602 lp = fs_cat(fld, 0, "knowledge/status/frontier_proposals_" as *u8) 1603 pp = fs_cat(plane, 0, "frontierprop-" as *u8) 1604 } 1605 plane[pp] = 0 as u8 1606 lp = fs_cat(fld, lp, dbase) 1607 lp = fs_cat(fld, lp, ".txt" as *u8) 1608 fld[lp] = 0 as u8 1609 let wrote: i64 = dp_writefile(fld, wl, wp) 1610 fs_w("WORKLIST path=" as *u8); fs_w(fld) 1611 fs_w(" bytes=" as *u8); fs_n(wp) 1612 fs_w(" wrote=" as *u8); fs_n(wrote); fs_w("\n" as *u8) 1613 let ppos: *i64 = sys_mmap(8 * FS_MAXP) as *i64 1614 let idb: *u8 = sys_mmap(FS_TXTCAP) 1615 let f1: *u8 = sys_mmap(FS_LINECAP) 1616 let f2: *u8 = sys_mmap(FS_LINECAP) 1617 let f3: *u8 = sys_mmap(FS_LINECAP) 1618 let f4: *u8 = sys_mmap(FS_LINECAP) 1619 let pargs: *i64 = sys_mmap(8 * (FS_PLANE_ARGS + 2)) as *i64 1620 var pi: i64 = 0 1621 var filed: i64 = 0 1622 while pi < wp { 1623 let ple: i64 = fs_eol(wl, wp, pi) 1624 if ple > pi { 1625 let pnp: i64 = fs_pipes(wl, pi, ple, ppos) 1626 if pnp >= 6 { 1627 var ip: i64 = fs_catn(idb, 0, wl, ppos[0] + 1, ppos[1]) 1628 idb[ip] = FS_USCORE as u8; ip = ip + 1 1629 ip = fs_hex(idb, ip, fs_urlhash(wl, ppos[3] + 1, ppos[4])) 1630 idb[ip] = 0 as u8 1631 let g1: i64 = fs_catn(f1, 0, wl, ppos[1] + 1, ppos[2]); f1[g1] = 0 as u8 1632 let g2: i64 = fs_catn(f2, 0, wl, ppos[2] + 1, ppos[3]); f2[g2] = 0 as u8 1633 let g3: i64 = fs_catn(f3, 0, wl, ppos[3] + 1, ppos[4]); f3[g3] = 0 as u8 1634 let g4: i64 = fs_catn(f4, 0, wl, ppos[4] + 1, ppos[5]); f4[g4] = 0 as u8 1635 pargs[0] = plane as i64 1636 pargs[1] = "put" as i64 1637 pargs[2] = "nx_frontier_scan" as i64 1638 pargs[3] = idb as i64 1639 pargs[4] = dbase as i64 1640 pargs[5] = f1 as i64 1641 pargs[6] = f2 as i64 1642 pargs[7] = f3 as i64 1643 pargs[8] = f4 as i64 1644 pargs[9] = "OPEN" as i64 1645 var prc: i64 = dep_run_capture("./nx_store_put.elf" as *u8, pargs, FS_PLANE_ARGS, "/tmp/nx_frontier_scan/put.out" as *u8) 1646 if prc == 127 { prc = dep_run_capture("_offc/nx_store_put.elf" as *u8, pargs, FS_PLANE_ARGS, "/tmp/nx_frontier_scan/put.out" as *u8) } 1647 if prc == 0 { filed = filed + 1 } 1648 } 1649 } 1650 pi = ple + 1 1651 } 1652 fs_w("PLANE " as *u8); fs_w(plane); fs_w(" filed=" as *u8); fs_n(filed) 1653 fs_w(" of=" as *u8); fs_n(total_props); fs_w("\n" as *u8) 1654 } 1655 1656 fs_w("NOTE proposals only -- this organ never writes .matrix, .refs, or a watch cell\n" as *u8) 1657 sys_exit(0) 1658 return 0 1659}