code wiki / (root) / nx_frontier_scan_gate.nx
`nx_frontier_scan_gate.nx` source

↩ module page · 309 lines · 19814 B
1// nx_frontier_scan_gate.nx -- the referee for the autonomous frontier-noticer (nx_frontier_scan).
2//
3// SUBJECT: the DEPLOYED ./nx_frontier_scan.elf, forked per tooth. This is an END-TO-END gate, so
4// nx_gate_bite must be given the 4th argument (subject target) or every mutant survives by construction.
5//
6// WHAT IT PROVES, AND WHAT IT DELIBERATELY DOES NOT:
7//   PROVES, deterministically and offline -- the internal deficit signal fires exactly when a rival
8//   leads a row we do not exceed; that it stays silent in BOTH directions of "no gap"; that the
9//   partition sums; that the seeds come from the domain's own data; that the thresholds are read from
10//   the conf and ECHOED so the bar is visible; that a missing board REFUSES by name; and that a run
11//   NEVER WRITES THE BOARD IT READS.
12//   DOES NOT PROVE -- the outbound half. A gate that fetches the live web on a beat is a gate that
13//   hammers the box and goes RED when someone else's server is slow. The network leg's accept rule is
14//   the METAHUMAN REPLAY (see the lane-E memory), which is a re-runnable harness, not a beat.
15//   That imprecision is stated here rather than left for the next reader to discover.
16//
17// FIXTURES ARE ASSEMBLED AT RUNTIME UNDER /tmp/nx_frontier_scan_gate/ -- a gate must not share its
18// fixture with a production beat, and a detector that scans source would otherwise find its own fixture.
19// Idempotent: every run rewrites every fixture, so the second run reports on the same conditions as the
20// first (A GATE THAT IS NOT IDEMPOTENT REPORTS ON ITS FIRST RUN AND LIES ABOUT EVERY RUN AFTER).
21//
22// 100% sovereign. No hardware writes (Rule 26). license_tier: ORIGINAL  expect_exit: 0
23import "nx_syscalls.nx"
24import "nx_deploy_lib.nx"
25import "nx_gate_verdict.nx"
26
27const FG_DIRMODE: i64 = 0x1ed
28const FG_PATHCAP: i64 = 1024
29const FG_ARGCAP:  i64 = 64
30
31func fg_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
32func fg_cat(d: *u8, o: i64, s: *u8) -> i64 {
  var p: i64 = o
  var i: i64 = 0
  let n: i64 = fg_len(s)
  while i < n { d[p] = s[i]; p = p + 1; i = i + 1 }
  return p
38}
39// does buf[0..n) contain lit?
40func fg_has(buf: *u8, n: i64, lit: *u8) -> i64 {
  let l: i64 = fg_len(lit)
  if l <= 0 { return 0 }
  if n < l { return 0 }
  var i: i64 = 0
  while i <= n - l {
      var j: i64 = 0
      var m: i64 = 1
      while j < l { if buf[i+j] != lit[j] { m = 0; j = l } else { j = j + 1 } }
      if m == 1 { return 1 }
      i = i + 1
  }
  return 0
53}
54func fg_put(path: *u8, body: *u8) -> i64 { return dp_writefile(path, body, fg_len(body)) }
55// how many NON-OVERLAPPING times lit occurs in buf[0..n) -- the idempotence tooth needs a COUNT, not a presence
56func fg_count(buf: *u8, n: i64, lit: *u8) -> i64 {
  let l: i64 = fg_len(lit)
  if l <= 0 { return 0 }
  var c: i64 = 0
  var i: i64 = 0
  while i + l <= n {
      var j: i64 = 0
      var m: i64 = 1
      while j < l { if buf[i+j] != lit[j] { m = 0; j = l } else { j = j + 1 } }
      if m == 1 { c = c + 1; i = i + l } else { i = i + 1 }
  }
  return c
68}
69
70// run the SUBJECT with up to three args, capturing stdout+stderr; returns bytes captured (0 if none).
71func fg_run(a1: *u8, a2: *u8, a3: *u8, nargs: i64, outfile: *u8, buf: *u8, blen: *i64) -> i64 {
  let args: *i64 = sys_mmap(FG_ARGCAP) as *i64
  args[0] = a1 as i64
  args[1] = a2 as i64
  args[2] = a3 as i64
  var rc: i64 = dep_run_capture("./nx_frontier_scan.elf" as *u8, args, nargs, outfile)
  if rc == 127 { rc = dep_run_capture("_offc/nx_frontier_scan.elf" as *u8, args, nargs, outfile) }
  let ob: *u8 = sys_read_file(outfile, blen)
  if (ob as i64) == 0 { blen[0] = 0; return 0 }
  let n: i64 = blen[0]
  var i: i64 = 0
  while i < n { buf[i] = ob[i]; i = i + 1 }
  return n
84}
85
86// SEVEN-ARG RUNNER. pairprobe takes a verb, a file and five delimiters; fg_run only carries three.
87func fg_run7(a1: *u8, a2: *u8, a3: *u8, a4: *u8, a5: *u8, a6: *u8, a7: *u8,
           outfile: *u8, buf: *u8, blen: *i64) -> i64 {
  let args: *i64 = sys_mmap(FG_ARGCAP) as *i64
  args[0] = a1 as i64
  args[1] = a2 as i64
  args[2] = a3 as i64
  args[3] = a4 as i64
  args[4] = a5 as i64
  args[5] = a6 as i64
  args[6] = a7 as i64
  var rc: i64 = dep_run_capture("./nx_frontier_scan.elf" as *u8, args, 7, outfile)
  if rc == 127 { rc = dep_run_capture("_offc/nx_frontier_scan.elf" as *u8, args, 7, outfile) }
  let ob: *u8 = sys_read_file(outfile, blen)
  if (ob as i64) == 0 { blen[0] = 0; return 0 }
  let n: i64 = blen[0]
  var i: i64 = 0
  while i < n { buf[i] = ob[i]; i = i + 1 }
  return n
105}
106
107func main(argc: i64, argv: *i64) -> i64 {
  gv_head("=== nx_frontier_scan_gate -- the autonomous frontier-noticer, refereed ===" as *u8)
  let ctr: *i64 = gv_ctr()
110
  sys_mkdir("/tmp/nx_frontier_scan_gate" as *u8, FG_DIRMODE)
112
  // ---- SETUP: four fixture boards, written fresh every run ----
  // fxA: ONE row where two rivals are Best (code 2) and our symbol is _ABSENT_, exceed=0 -> DEFICIT.
  fg_put("/tmp/nx_frontier_scan_gate/fxa.matrix" as *u8,
      "@title FX\n@cols R1|R2|R3|R4\nHAIR strand hair from the genome|runtime/nx_fx.nx|_ABSENT_:fx_hair|0|2|2|1|0|two rivals are Best and we are absent\n" as *u8)
  fg_put("/tmp/nx_frontier_scan_gate/fxa.axes" as *u8,
      "@title FX\nHAIR strand hair from the genome|runtime/nx_fx.nx|_ABSENT_|strand hair;real-time groom\n" as *u8)
  fg_put("/tmp/nx_frontier_scan_gate/fxa.refs" as *u8,
      "ref|fxref|A fixture citation.|https://example.invalid/fixture|-|-|2026-08-20|vendor-doc|the fixture row\n" as *u8)
  // fxB: THE SAME ROW WITH OUR EXCEED FLAG SET. If the detector still calls this a deficit it is
  // measuring "a rival exists", not "a rival is ahead of us".
  fg_put("/tmp/nx_frontier_scan_gate/fxb.matrix" as *u8,
      "@title FX\n@cols R1|R2|R3|R4\nHAIR strand hair from the genome|runtime/nx_fx.nx|fx_hair|1|2|2|1|0|we exceed here\n" as *u8)
  // fxC: THE SAME ROW WITH NO RIVAL AT BEST. If the detector still fires it is measuring _ABSENT_ alone.
  fg_put("/tmp/nx_frontier_scan_gate/fxc.matrix" as *u8,
      "@title FX\n@cols R1|R2|R3|R4\nHAIR strand hair from the genome|runtime/nx_fx.nx|_ABSENT_:fx_hair|0|1|1|0|0|nobody leads\n" as *u8)
  // fxD: THREE rows, exactly ONE of them a deficit -- the partition must reconcile, not merely print.
  fg_put("/tmp/nx_frontier_scan_gate/fxd.matrix" as *u8,
      "@title FX\n@cols R1|R2|R3|R4\nHAIR strand hair from the genome|runtime/nx_fx.nx|_ABSENT_:fx_hair|0|2|2|1|0|deficit\nSKIN we already exceed|runtime/nx_fx.nx|fx_skin|1|2|2|2|2|not a deficit, we exceed\nMESH nobody leads|runtime/nx_fx.nx|fx_mesh|0|1|0|0|0|not a deficit, no rival at Best\n" as *u8)
131
  let buf: *u8 = sys_mmap(1 << 20)
  let blen: *i64 = sys_mmap(16) as *i64
  let out: *u8 = "/tmp/nx_frontier_scan_gate/run.out" as *u8
135
  // ---- 1. the detector FIRES on the crafted deficit ----
  var n: i64 = fg_run("deficit" as *u8, "/tmp/nx_frontier_scan_gate/fxa" as *u8, 0 as *u8, 2, out, buf, blen)
  let fires_a: i64 = fg_has(buf, n, "DEFICIT-ROWS=1" as *u8)
  gv_check("deficit-fires-when-a-rival-leads-and-we-are-absent" as *u8, fires_a, ctr)
  // the subject must actually have RUN -- ASSERT THE FIXTURE REACHED THE CONDITION BEFORE ASSERTING
  // THE OUTCOME, or a fork that produced nothing scores as a clean silence.
  var ran: i64 = 0
  if n > 0 { ran = fg_has(buf, n, "CONF lead_code=" as *u8) }
  gv_check("subject-actually-ran-and-emitted-its-conf-line" as *u8, ran, ctr)
145
  // ---- 2+3. the two NEGATIVE CONTROLS, which are also the POSITIVE CONTROL for the whole loop:
  // a domain with no real gap must produce no proposal, and must do it without touching the network.
  n = fg_run("deficit" as *u8, "/tmp/nx_frontier_scan_gate/fxb" as *u8, 0 as *u8, 2, out, buf, blen)
  let quiet_b: i64 = fg_has(buf, n, "DEFICIT-ROWS=0" as *u8)
  gv_check("neg-control-silent-when-our-exceed-flag-is-set" as *u8, quiet_b, ctr)
  gv_bite("bite-deficit-discriminates-exceed-from-not-exceed" as *u8, fires_a, 1 - quiet_b, ctr)
152
  n = fg_run("deficit" as *u8, "/tmp/nx_frontier_scan_gate/fxc" as *u8, 0 as *u8, 2, out, buf, blen)
  let quiet_c: i64 = fg_has(buf, n, "DEFICIT-ROWS=0" as *u8)
  gv_check("neg-control-silent-when-no-rival-is-at-Best" as *u8, quiet_c, ctr)
  gv_bite("bite-deficit-needs-a-rival-lead-not-merely-an-absent-symbol" as *u8, fires_a, 1 - quiet_c, ctr)
157
  // ---- 4. the partition RECONCILES on a board where the answer is known by construction ----
  n = fg_run("deficit" as *u8, "/tmp/nx_frontier_scan_gate/fxd" as *u8, 0 as *u8, 2, out, buf, blen)
  let sums: i64 = fg_has(buf, n, "rows_total=3 deficit=1 not_deficit=2" as *u8)
  gv_check("deficit-partition-sums-to-rows-total" as *u8, sums, ctr)
162
  // ---- 5. THE WHOLE-LOOP POSITIVE CONTROL: propose on a no-gap board fetches nothing, proposes
  // nothing, and says so. A guard that refuses everything passes every negative test; this is the
  // input that MUST come back empty, and it must come back empty for the RIGHT REASON.
  n = fg_run("propose" as *u8, "/tmp/nx_frontier_scan_gate/fxb" as *u8, 0 as *u8, 2, out, buf, blen)
  var nogap: i64 = 0
  if fg_has(buf, n, "fetches=0 PROPOSALS=0" as *u8) == 1 { nogap = fg_has(buf, n, "NO-DEFICIT domain=" as *u8) }
  gv_check("neg-control-no-gap-board-issues-zero-fetches-and-zero-proposals" as *u8, nogap, ctr)
170
  // ---- 6+7. seeds come from the domain's OWN data, and the declared frontier keywords are consumed ----
  n = fg_run("seeds" as *u8, "/tmp/nx_frontier_scan_gate/fxa" as *u8, 0 as *u8, 2, out, buf, blen)
  gv_check("seeds-derived-from-the-matrix-row-labels" as *u8, fg_has(buf, n, "SEED matrix " as *u8), ctr)
  gv_check("seeds-consume-the-declared-axes-frontier-keywords" as *u8, fg_has(buf, n, "SEED axes strand hair" as *u8), ctr)
175
  // ---- 8. THE BAR IS VISIBLE. A chain that measures an envelope and then drops it at the next hop
  // published nothing; every threshold this organ decides on is echoed in its own output.
  n = fg_run("deficit" as *u8, "/tmp/nx_frontier_scan_gate/fxa" as *u8, 0 as *u8, 2, out, buf, blen)
  var bar: i64 = 0
  if fg_has(buf, n, "lead_code=" as *u8) == 1 {
      if fg_has(buf, n, "cover_permil=" as *u8) == 1 {
          if fg_has(buf, n, "seed_tokens=" as *u8) == 1 {
              if fg_has(buf, n, "props_per_row=" as *u8) == 1 { bar = 1 }
          }
      }
  }
  gv_check("every-threshold-it-decides-on-is-echoed-in-its-own-output" as *u8, bar, ctr)
188
  // ---- 9. a missing board REFUSES BY NAME rather than reporting an empty world ----
  n = fg_run("deficit" as *u8, "/tmp/nx_frontier_scan_gate/fx_does_not_exist" as *u8, 0 as *u8, 2, out, buf, blen)
  gv_check("neg-control-missing-board-refuses-by-name-not-silently-empty" as *u8,
           fg_has(buf, n, "reason=no-matrix" as *u8), ctr)
193
  // ---- 10. THE SAFETY TOOTH: a run never writes the board it reads. This is the conjunct the whole
  // proposals-never-admits discipline rests on, so it is measured on the ARTIFACT, not asserted.
  let plen: *i64 = sys_mmap(16) as *i64
  let before: *u8 = sys_read_file("/tmp/nx_frontier_scan_gate/fxa.matrix" as *u8, plen)
  var bn: i64 = 0
  let bcopy: *u8 = sys_mmap(1 << 16)
  if (before as i64) != 0 {
      bn = plen[0]
      var i: i64 = 0
      while i < bn { bcopy[i] = before[i]; i = i + 1 }
  }
  // DELIBERATELY `deficit`, NOT `propose`: this gate issues NO outbound request. The first cut ran
  // propose here, which fetched the live web AND filed fixture rows into the production frontierprop-
  // plane, where it blocked on that plane's flock -- a gate sharing a production surface, caught by the
  // gate hanging rather than by any tooth. The write path is covered by the no-gap tooth above, which
  // reaches the filing branch and returns before any fetch.
  fg_run("deficit" as *u8, "/tmp/nx_frontier_scan_gate/fxa" as *u8, 0 as *u8, 2, out, buf, blen)
  let after: *u8 = sys_read_file("/tmp/nx_frontier_scan_gate/fxa.matrix" as *u8, plen)
  var same: i64 = 0
  if (after as i64) != 0 {
      if plen[0] == bn {
          same = 1
          var j: i64 = 0
          while j < bn { if after[j] != bcopy[j] { same = 0; j = bn } else { j = j + 1 } }
      }
  }
  var could: i64 = 0
  if bn > 0 { could = 1 }
  if gv_need("fixture board readable before and after" as *u8, could, ctr) == 1 {
      gv_check("a-run-never-writes-the-board-it-reads" as *u8, same, ctr)
  }
225
  // ---- 11. the source registry must exist, or the outbound leg is UNOBSERVABLE rather than absent ----
  let slen: *i64 = sys_mmap(16) as *i64
  let sb: *u8 = sys_read_file("knowledge/frontier_sources.conf" as *u8, slen)
  var have_src: i64 = 0
  if (sb as i64) != 0 { if slen[0] > 0 { have_src = fg_has(sb, slen[0], "src|arxiv|" as *u8) } }
  if gv_need("knowledge/frontier_sources.conf carrying at least the arxiv row" as *u8, have_src, ctr) == 1 {
      var no_websearch: i64 = 1
      if fg_has(sb, slen[0], "src|websearch|" as *u8) == 1 { no_websearch = 0 }
      gv_check("sources-are-data-and-exclude-the-own-crawl-index-that-cannot-see-the-outside" as *u8, no_websearch, ctr)
  }
236
  // ---- PAIRING: EVERY FIELD BELONGS TO ITS OWN ITEM (2026-08-20, lane E) ----------------------------
  // ★★★★★★A PROPOSAL WHOSE URL DOES NOT BELONG TO ITS TITLE IS A FABRICATED CITATION IN THE MAKING --
  // the same defect class the 2026-08-20 audit spent a day retracting off /compare/charsim, caught one
  // step UPSTREAM, before it can ever reach a refs row.
  // WHAT WENT WRONG: the v1 extractor searched every field from the item delimiter TO THE END OF THE
  // BUFFER. Measured live on HN Algolia, where Ask HN and Launch HN text posts carry NO url key at all,
  // TWO ADJACENT url-less items both reported the SAME downstream url under DIFFERENT titles.
  // FIXTURE SHAPE IS THE WHOLE POINT: two ADJACENT items, the FIRST deliberately missing its url field.
  // Nothing else can catch a borrowed field -- a single item, or two items that both carry every field,
  // passes with or without the bound.
  // ⚠THE DELIMITERS HERE ARE DELIBERATELY NOT JSON. The boundary rule is delimiter-agnostic by
  // construction (the extractor takes its markers as data), so a quote-free fixture exercises the exact
  // same fs_item_end bound while avoiding a lexer escape this gate does not need to depend on. The
  // REAL-BYTES proof is the metahuman replay over live HN, which is the harness's job, not a gate's.
  sys_mkdir("/tmp/nx_frontier_scan_gate" as *u8, FG_DIRMODE)
  fg_put("/tmp/nx_frontier_scan_gate/pairfx.txt" as *u8,
         "ITEM T=alpha which has no url;ITEM T=beta;U=https://example.org/beta;\n" as *u8)
  let pbuf: *u8 = sys_mmap(FG_PATHCAP * FG_PATHCAP)
  let plen: *i64 = sys_mmap(16) as *i64
  let pn: i64 = fg_run7("pairprobe" as *u8, "/tmp/nx_frontier_scan_gate/pairfx.txt" as *u8,
                        "ITEM " as *u8, "T=" as *u8, ";" as *u8, "U=" as *u8, ";" as *u8,
                        "/tmp/nx_frontier_scan_gate/pairfx.out" as *u8, pbuf, plen)
  // ★ASSERT THE FIXTURE REACHED THE CONDITION BEFORE ASSERTING THE OUTCOME: a probe that saw one item,
  // or none, would pass every pairing tooth below by never exercising a boundary at all.
  gv_check("pairprobe-fixture-reached-the-condition-two-adjacent-items" as *u8,
           fg_has(pbuf, pn, "PAIRPROBE items=2" as *u8), ctr)
  gv_check("neg-control-a-url-less-item-is-UNPAIRED-not-lent-its-neighbours-url" as *u8,
           fg_has(pbuf, pn, "paired=1 unpaired=1" as *u8), ctr)
  var pin_bad: i64 = 1
  if fg_has(pbuf, pn, "url_in_own_item=0" as *u8) == 1 { pin_bad = 0 }
  gv_check("pairing-every-emitted-url-lies-inside-its-own-items-extent" as *u8,
           (fg_has(pbuf, pn, "url_in_own_item=1" as *u8)) & pin_bad, ctr)
  var no_borrow: i64 = 1
  if fg_has(pbuf, pn, "title=alpha which has no url url=" as *u8) == 1 { no_borrow = 0 }
  gv_check("neg-control-a-borrowed-url-never-appears-beside-the-url-less-title" as *u8, no_borrow, ctr)
272
  // ---- ATTEST (2026-09-06): the month reader and the idempotent attestation, both OFFLINE -----------------
  // monthprobe reads the newest month across dated items, counts an undated item as seen-not-dated, takes a
  // fixed month=YYYY-MM spec for every item (a conference index), and ABSTAINS with NONE when nothing dates.
  fg_put("/tmp/nx_frontier_scan_gate/monthfx.txt" as *u8,
         "ITEM D=2026-05-02;T=alpha;ITEM D=2026-07-22;T=beta;ITEM T=gamma-undated;ITEM D=2026-06-11;T=delta;\n" as *u8)
  let mbuf: *u8 = sys_mmap(FG_PATHCAP * FG_PATHCAP)
  let mlen: *i64 = sys_mmap(16) as *i64
  let mfx: *u8 = "/tmp/nx_frontier_scan_gate/monthfx.txt" as *u8
  let mout: *u8 = "/tmp/nx_frontier_scan_gate/monthfx.out" as *u8
  var mn: i64 = fg_run7("monthprobe" as *u8, mfx, "ITEM " as *u8, "D=" as *u8, ";" as *u8, "-" as *u8, "-" as *u8, mout, mbuf, mlen)
  gv_check("monthprobe-fixture-reached-the-condition-four-items" as *u8, fg_has(mbuf, mn, "MONTHPROBE items=4" as *u8), ctr)
  gv_check("monthprobe-reads-the-newest-month-across-dated-items-not-the-first" as *u8, fg_has(mbuf, mn, "newest=2026-07" as *u8), ctr)
  gv_check("monthprobe-counts-an-undated-item-as-seen-not-dated" as *u8, fg_has(mbuf, mn, "items=4 dated=3" as *u8), ctr)
  mn = fg_run7("monthprobe" as *u8, mfx, "ITEM " as *u8, "month=2026-08" as *u8, "-" as *u8, "-" as *u8, "-" as *u8, mout, mbuf, mlen)
  gv_check("fixed-month-spec-dates-every-item-with-that-month" as *u8, fg_has(mbuf, mn, "items=4 dated=4 newest=2026-08" as *u8), ctr)
  mn = fg_run7("monthprobe" as *u8, mfx, "ITEM " as *u8, "X=" as *u8, ";" as *u8, "-" as *u8, "-" as *u8, mout, mbuf, mlen)
  gv_check("neg-control-undated-listing-abstains-with-NONE-never-a-month" as *u8, fg_has(mbuf, mn, "dated=0 newest=NONE" as *u8), ctr)
  // attestfile appends exactly ONE barscan row per (date, ref): the second run is a no-op, so a beat cannot grow
  // a plan by a row per tick, and the row carries the newest month the reader found plus its note.
  let afx: *u8 = "/tmp/nx_frontier_scan_gate/att.plan" as *u8
  fg_put(afx, "sotabar|SB-FX|2026-07|fixture subject|what july says|fxref|note\n" as *u8)
  let aout: *u8 = "/tmp/nx_frontier_scan_gate/att.out" as *u8
  mn = fg_run7("attestfile" as *u8, afx, "fxref" as *u8, "2026-09-06" as *u8, "2026-07" as *u8, "fixture attestation" as *u8, "-" as *u8, aout, mbuf, mlen)
  gv_check("attestfile-first-run-appends-rc1" as *u8, fg_has(mbuf, mn, "ATTESTFILE rc=1" as *u8), ctr)
  mn = fg_run7("attestfile" as *u8, afx, "fxref" as *u8, "2026-09-06" as *u8, "2026-07" as *u8, "fixture attestation" as *u8, "-" as *u8, aout, mbuf, mlen)
  gv_check("attestfile-second-run-is-a-no-op-rc0" as *u8, fg_has(mbuf, mn, "ATTESTFILE rc=0" as *u8), ctr)
  let alen: *i64 = sys_mmap(16) as *i64
  let ab: *u8 = sys_read_file(afx, alen)
  var arows: i64 = 0
  var aok: i64 = 0
  if (ab as i64) != 0 { arows = fg_count(ab, alen[0], "barscan|2026-09-06|fxref|newest=2026-07|" as *u8); aok = fg_has(ab, alen[0], "fixture attestation" as *u8) }
  gv_check("attestfile-exactly-one-barscan-row-after-two-runs-idempotent-per-date-and-ref" as *u8, arows == 1, ctr)
  gv_check("attestfile-row-carries-the-newest-month-and-the-note" as *u8, aok, ctr)
306
  return gv_verdict("nx_frontier_scan_gate" as *u8, ctr,
      "the outbound leg is proven by the metahuman replay harness, not by this gate -- a gate that fetches the live web on a beat hammers the box and reddens on someone else's latency" as *u8)
309}
nx_frontier_scan_gate.nx source

`nx_frontier_scan_gate.nx` source
