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

↩ module page · 262 lines · 10858 B
1// nx_vizsla_mcp_gate.nx -- GATE: the VIZSLA coordination tools are REAL MCP-level APIs. Drives the
2// EXACT execution layer /mcp tools/call uses (nx_tool_exec_allow tea_resolve/tea_run_argv over the
3// PRODUCTION tool_allowlist.conf) + the discovery registry readback (what tools/list serves) + the
4// rich-schema conf rows. Nothing is mocked: the resolved blessed ELFs run with a real argv and their
5// real stdout comes back through the capture path -- exactly what an MCP client receives.
6//
7// Rows:
8//   1 registry-discovery   tool_get readback for vizsla_plan + vizsla_doc (tools/list source)
9//   2 allowlist-resolve    tea_resolve(production conf) vizsla_plan -> TEA_OK + the blessed elf path
10//   3 mcp-exec-plan        tea_run_argv board over the demo store -> VIZSLA-PLAN-VERDICT captured
11//   4 mcp-exec-ics         tea_run_argv ics export -> real .ics on disk + BEGIN:VCALENDAR + verdict
12//   5 mcp-exec-doc         tea_run_argv doc put -> list captures docs=1 (mutating tool works e2e)
13//   6 blocked-non-green    nx_http_probe row is RED -> TEA_BLOCKED, nothing executed [neg control]
14//   7 notfound-unknown     ghost tool -> TEA_NOTFOUND [negative control]
15//   8 schema-rows          tool_schemas.conf carries vizsla_plan + vizsla_doc annotation rows
16// Evidence: VIZSLA-MCP-GATE -> stdout + knowledge/status/vizsla_gate.log; exit 0 iff 8/8.
17// expect_exit: 0  license_tier: ORIGINAL
18import "nx_tool_exec_allow.nx"
19import "nx_tool_registry.nx"
20import "nx_gate_verdict.nx"
21
22func mg_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
23func mg_p(s: *u8) -> i64 { sys_write(1, s, mg_slen(s)); return 0 }
24
25func mg_cat(dst: *u8, off: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while s[i] != (0 as u8) { dst[off + i] = s[i]; i = i + 1 }
  return off + i
29}
30
31func mg_catn(dst: *u8, off: i64, v: i64) -> i64 {
  var o: i64 = off
  var m: i64 = v
  if m < 0 { dst[o] = 45 as u8; o = o + 1; m = 0 - m }
  let t: *u8 = sys_mmap(28)
  var k: i64 = 0
  if m == 0 { t[0] = 48 as u8; k = 1 }
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { dst[o + i] = t[k - 1 - i]; i = i + 1 }
  return o + k
42}
43
44func mg_readall(path: *u8, szout: *i64) -> *u8 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { szout[0] = 0 - 1; return 0 as *u8 }
  let sz: i64 = sys_lseek(fd, 0, 2)
  sys_lseek(fd, 0, 0)
  let buf: *u8 = sys_mmap(sz + 64)
  var got: i64 = 0
  var n: i64 = 1
  while n > 0 {
      n = sys_read(fd, (buf as i64 + got) as *u8, 65536)
      if n > 0 { got = got + n }
  }
  sys_close(fd)
  szout[0] = got
  return buf
59}
60
61func mg_memhas(b: *u8, sz: i64, needle: *u8) -> i64 {
  let n: i64 = mg_slen(needle)
  if sz < n { return 0 }
  var i: i64 = 0
  while i + n <= sz {
      var ok: i64 = 1
      var j: i64 = 0
      while j < n {
          if b[i + j] != needle[j] { ok = 0; j = n } else { j = j + 1 }
      }
      if ok == 1 { return 1 }
      i = i + 1
  }
  return 0
75}
76
77func mg_filehas(path: *u8, needle: *u8) -> i64 {
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = mg_readall(path, szp)
  if szp[0] <= 0 { return 0 }
  return mg_memhas(b, szp[0], needle)
82}
83
84func mg_row(name: *u8, pass: i64) -> i64 {
  mg_p("ROW " as *u8)
  mg_p(name)
  if pass == 1 { mg_p(" PASS\n" as *u8) } else { mg_p(" FAIL\n" as *u8) }
  return pass
89}
90
91func main(argc: i64, argv: *i64) -> i64 {
  mg_p("=== VIZSLA MCP GATE: coordination tools live on the tools/call execution plane ===\n" as *u8)
  let conf: *u8 = "tool_allowlist.conf" as *u8
  var pass: i64 = 0
  var r: i64 = 0
96
  // row 1: discovery registry readback (the tools/list source)
  let p1: *i64 = sys_mmap(8) as *i64
  let l1: *i64 = sys_mmap(8) as *i64
  let g1: i64 = tool_get("vizsla_plan" as *u8, p1, l1)
  let g2: i64 = tool_get("vizsla_doc" as *u8, p1, l1)
  r = 0
  if g1 == 1 { if g2 == 1 { r = 1 } }
  pass = pass + mg_row("registry-discovery" as *u8, r)
105
  // row 2: production allowlist resolves the tool NAME to the blessed elf
  let path: *u8 = sys_mmap(4096)
  let code: i64 = tea_resolve_from(conf, "vizsla_plan" as *u8, 11, path, 4096)
  r = 0
  if code == TEA_OK {
      if mg_memhas(path, mg_slen(path), "_offc/nx_vizsla_plan.elf" as *u8) == 1 { r = 1 }
  }
  pass = pass + mg_row("allowlist-resolve" as *u8, r)
114
  // row 3: EXECUTE vizsla_plan board over the demo store via the tools/call layer
  let av: *i64 = sys_mmap(8 * 12) as *i64
  av[0] = 0
  av[1] = "board" as *u8 as i64
  av[2] = "knowledge/vizsla/demo/plan-" as *u8 as i64
  av[3] = "summer" as *u8 as i64
  av[4] = "2026-07-08" as *u8 as i64
  av[5] = 0
  let out: *u8 = sys_mmap(16384)
  let outlen: *i64 = sys_mmap(16) as *i64
  let rc: *i64 = sys_mmap(16) as *i64
  let x3: i64 = tea_run_argv_from(conf, "vizsla_plan" as *u8, 11, av, out, 16384, outlen, rc)
  r = 0
  if x3 == 0 { if rc[0] == TEA_OK {
      if mg_memhas(out, outlen[0], "VIZSLA-PLAN-VERDICT plan=summer" as *u8) == 1 {
          if mg_memhas(out, outlen[0], "VIZSLA-PLAN-CRITICAL plan=summer" as *u8) == 1 { r = 1 }
      }
  } }
  pass = pass + mg_row("mcp-exec-plan" as *u8, r)
134
  // row 4: EXECUTE vizsla_ics export -- a side-effectful tool writes a REAL artifact
  let av4: *i64 = sys_mmap(8 * 12) as *i64
  av4[0] = 0
  av4[1] = "export" as *u8 as i64
  av4[2] = "knowledge/vizsla/demo/cal-" as *u8 as i64
  av4[3] = "2026-07-01" as *u8 as i64
  av4[4] = "2026-12-31" as *u8 as i64
  av4[5] = "/tmp/vzm_mcp.ics" as *u8 as i64
  av4[6] = 0
  let x4: i64 = tea_run_argv_from(conf, "vizsla_ics" as *u8, 10, av4, out, 16384, outlen, rc)
  r = 0
  if x4 == 0 { if rc[0] == TEA_OK {
      if mg_memhas(out, outlen[0], "VIZSLA-ICS-VERDICT events=3 rules=2" as *u8) == 1 {
          if mg_filehas("/tmp/vzm_mcp.ics" as *u8, "BEGIN:VCALENDAR" as *u8) == 1 {
              if mg_filehas("/tmp/vzm_mcp.ics" as *u8, "RRULE:FREQ=YEARLY" as *u8) == 1 { r = 1 }
          }
      }
  } }
  pass = pass + mg_row("mcp-exec-ics" as *u8, r)
154
  // row 5: EXECUTE vizsla_doc put then list -- a MUTATING tool works end-to-end
  let fdw: i64 = sys_openat_wr("/tmp/vzm_doc.txt" as *u8, 0x1a4)
  if fdw >= 0 { sys_write(fdw, "mcp-plane document body\n" as *u8, 24); sys_close(fdw) }
  let pfx: *u8 = sys_mmap(128)
  var po: i64 = 0
  po = mg_cat(pfx, po, "/tmp/vzmD" as *u8)
  po = mg_catn(pfx, po, sys_now_us())
  po = mg_cat(pfx, po, "-" as *u8)
  pfx[po] = 0 as u8
  let av5: *i64 = sys_mmap(8 * 12) as *i64
  av5[0] = 0
  av5[1] = "put" as *u8 as i64
  av5[2] = pfx as i64
  av5[3] = "mcpdoc" as *u8 as i64
  av5[4] = "/tmp/vzm_doc.txt" as *u8 as i64
  av5[5] = "note" as *u8 as i64
  av5[6] = "plan:summer" as *u8 as i64
  av5[7] = "2026-07-08" as *u8 as i64
  av5[8] = "7401" as *u8 as i64
  av5[9] = 0
  let x5a: i64 = tea_run_argv_from(conf, "vizsla_doc" as *u8, 10, av5, out, 16384, outlen, rc)
  var ok5: i64 = 0
  if x5a == 0 { if mg_memhas(out, outlen[0], " new=1 segment=seg-7401" as *u8) == 1 { ok5 = 1 } }
  let av5b: *i64 = sys_mmap(8 * 8) as *i64
  av5b[0] = 0
  av5b[1] = "list" as *u8 as i64
  av5b[2] = pfx as i64
  av5b[3] = "-" as *u8 as i64
  av5b[4] = 0
  let x5b: i64 = tea_run_argv_from(conf, "vizsla_doc" as *u8, 10, av5b, out, 16384, outlen, rc)
  r = 0
  if ok5 == 1 { if x5b == 0 {
      if mg_memhas(out, outlen[0], "VIZSLA-DOC-LIST rel=- docs=1" as *u8) == 1 {
          if mg_memhas(out, outlen[0], "docid=mcpdoc doctype=note rel=plan:summer" as *u8) == 1 { r = 1 }
      }
  } }
  pass = pass + mg_row("mcp-exec-doc" as *u8, r)
  // NOTE: the COMPOSING tool vizsla_notify (which double-forks: tools/call -> notify -> remind) is proven
  // over tools/call by the SEPARATE nx_vizsla_notify_mcp_gate (3/3), kept in a fresh minimal process so the
  // degraded WSL box's fork-accumulation flake (a 5th+ tr_run_capture fork can transiently fail) never
  // masks a real result. Splitting keeps both gates deterministically GREEN and honest.
196
  // row 6: RED-status tool is BLOCKED (negative control -- allowlist status is load-bearing)
  let code6: i64 = tea_resolve_from(conf, "nx_http_probe" as *u8, 13, path, 4096)
  r = 0
  if code6 == TEA_BLOCKED { r = 1 }
  pass = pass + mg_row("blocked-non-green" as *u8, r)
202
  // row 7: unknown tool -> NOTFOUND (negative control)
  let code7: i64 = tea_resolve_from(conf, "vizsla_ghost" as *u8, 12, path, 4096)
  r = 0
  if code7 == TEA_NOTFOUND { r = 1 }
  pass = pass + mg_row("notfound-unknown" as *u8, r)
208
  // row 8: rich MCP annotation rows present (tab-separated -- needles built with real TABs)
  let nd: *u8 = sys_mmap(64)
  var no: i64 = 0
  no = mg_cat(nd, no, "vizsla_plan" as *u8)
  nd[no] = 9 as u8; no = no + 1
  no = mg_cat(nd, no, "Vizsla Planner" as *u8)
  nd[no] = 0 as u8
  let nd2: *u8 = sys_mmap(64)
  no = 0
  no = mg_cat(nd2, no, "vizsla_doc" as *u8)
  nd2[no] = 9 as u8; no = no + 1
  no = mg_cat(nd2, no, "Vizsla Documents" as *u8)
  nd2[no] = 0 as u8
  r = 0
  if mg_filehas("knowledge/tool_schemas.conf" as *u8, nd) == 1 {
      if mg_filehas("knowledge/tool_schemas.conf" as *u8, nd2) == 1 { r = 1 }
  }
  pass = pass + mg_row("schema-rows" as *u8, r)
227
  let permil: i64 = (pass * 1000) / 8
  let logfd: i64 = sys_openat_append("knowledge/status/vizsla_gate.log" as *u8, 0x1a4)
  var fdi: i64 = 0
  while fdi < 2 {
      var fd: i64 = 1
      if fdi == 1 { fd = logfd }
      if fd > 0 {
          let line: *u8 = sys_mmap(256)
          var o: i64 = 0
          o = mg_cat(line, o, "VIZSLA-MCP-GATE epoch=" as *u8)
          o = mg_catn(line, o, sys_now_realtime_sec())
          o = mg_cat(line, o, " rows=8 pass=" as *u8)
          o = mg_catn(line, o, pass)
          o = mg_cat(line, o, " permil=" as *u8)
          o = mg_catn(line, o, permil)
          if pass == 8 {
              o = mg_cat(line, o, " verdict=GREEN\n" as *u8)
          } else {
              o = mg_cat(line, o, " verdict=RED\n" as *u8)
          }
          sys_write(fd, line, o)
      }
      fdi = fdi + 1
  }
  if logfd > 0 { sys_close(logfd) }
  // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
  // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
  // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
  let ctr__dry: *i64 = gv_ctr()
  ctr__dry[0] = pass
  ctr__dry[1] = 8
  let rc__dry: i64 = gv_verdict("VIZSLA-MCP-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
  sys_exit(rc__dry)
  return rc__dry
262}
nx_vizsla_mcp_gate.nx source

`nx_vizsla_mcp_gate.nx` source
