MathSphere Nexus official corporate seal MathSphere Nexus

Wizard Central Pro AI Modes Toolkit — README

The README as published in the project's repository

Site note: this project is a private repository — cloning it needs a GitHub account the owner has added as a collaborator. The README is published here so its claims can be checked before anyone asks for access; the same note stands where the clone command does, below.

🧙 wizard-central-pro-AI-modes-toolkit

A toolkit of command-line wizards that a person, or a language model on the same machine, can run, with a gate in front of everything a model may touch. What is in it, counted from the code:

Everything here is checked by tests, and nothing is meant to be claimed that a test does not prove. Sections marked generated are written by python3 scripts/gen_readme.py from the code; tests/test_readme_gen.py fails when they are out of date, or when the code needs something they do not mention.

Before you share this repository: the ported wizards' code is private, copied from the owner's wizard_central (wizards/PORTING.md).


✅ Status

Generated.

Piece State
Runnable wizards: engine.ported.run has 39 entries (37 ported from wizard_central plus 2 new: @grantwiz, @mcpwiz), 486 commands Built, tested (tests/test_ported.py, one test file per wizard)
Command-line wizards ported from wizard_central 38 originals ported as 37 wizards; 0 remain. 3 set aside by the owner, may return later (@rustwiz, @tmuxwiz, @fleetwiz). Rosters: wizards/PORTING.md, docs/BASE_ROSTER.md
MCP bridge (mcp/server.py) and its settings wizard @mcpwiz Built, tested (tests/test_mcp_server.py, tests/test_mcpwiz.py). 12 wizards ship an mcp.json listing 139 commands: 107 can be offered as tools once a person switches them on, 32 are never. Client verified end to end: ollmcp
Guard modes in the bridge 9 built of 23 planned, tested (tests/test_guardrails.py, tests/test_mcp_server.py)
Sandbox wall around every bridge call Built, tested on Linux (tests/test_sandbox.py): Landlock limits files, seccomp denies socket, connect, io_uring_setup and ptrace. Not available on macOS or Windows
Folder grants and the hash-chained receipts log Built, tested (tests/test_mcpwiz.py, tests/test_grantwiz.py)
The godfatherwiz REPL (a local model that can call wizards) Works with Ollama. Its model may call only 7 reviewed look-only wizards (76 commands); this is containment, not the bridge's gate (tests/test_godfatherwiz_repl.py)
Wizard roster: 39 built of 41 planned, in 25 categories (design cards for more stand in the registry; a card is not a wizard until it is built) Registry data, tested. 39 of the 110 have code here; the other 71 are descriptions only and cannot be run
Tool export (export_llm_tools): 110 function schemas, with an optional category filter Built, tested. The schemas include the 71 roster wizards with no code: a model given them can name tools that do not exist here
70 AI modes with full prompts (docs/MODES.md) and compose() (75 registry entries in all, counting the 5 guard modes) Built, tested: the prompt text and its SHA-256 fingerprint are reproducible. What a mode does to a model's answers is not measured
Your own modes and guard rules (custom_modes.py, guardrails.py) Built, tested; each is approved by hash (docs/CUSTOM_MODES.md)
The test loop and the commit check (scripts/loop.py, scripts/precommit_check.py) Built, tested (tests/test_automation.py). The loop runs 66 test files
License check and subscriber certification (license.py, conductor_certifier.py) Code present, tested (tests/test_license_and_certifier.py). The license check is a placeholder, not protection (docs/ARCHITECTURE.md)
pip packaging Not built: no PyPI package and no single console command. Run from the repository

📦 What you need

Generated. Nothing here is needed all at once: install only what the part you want to use needs.

Python 3.12 or newer (tested on 3.13). The registry, compose() and most wizards use only the standard library. Linux for the sandbox wall; the rest is tested on Linux only (Debian, and Chromebook Linux). macOS and Windows are not tested.

Python packages, only for the parts that use them (pip install <name>, in a virtual environment):

Package Needed by Without it
mcp the MCP bridge (mcp/server.py), tests/test_mcp_server.py version 2.x; without it the bridge prints the install command and stops
py_landlock the sandbox wall around every bridge call (scripts/sandbox_wrapper.py) Linux with Landlock (kernel 5.13 or newer); without it the wall cannot be proven and no call runs
pyseccomp the sandbox wall (scripts/sandbox_wrapper.py) Linux; denies socket, connect, io_uring_setup and ptrace inside the wall
click required by calendarwiz calendarwiz does not start: it prints one [FAIL] line naming the missing package and pointing at requirementswiz setup calendarwiz (it printed a traceback until D27, 2026-10-27)
py_landlock optional for requirementswiz requirementswiz setup --all cannot probe the sandbox wall without it, and says so instead; the bridge's wall needs it too (see the bridge packages above)
pyfiglet required by bannerwiz; optional for godfatherwiz bannerwiz says [FAIL] missing package(s) with the install command; godfatherwiz prints a plain title instead of the banner
pyseccomp optional for requirementswiz requirementswiz setup --all cannot probe the sandbox wall without it, and says so instead; the bridge's wall needs it too (see the bridge packages above)
pytest optional for supremewiz supremewiz test refuses: pytest is not installed in this Python, with the install command
rich required by bannerwiz, calendarwiz; optional for examwiz, godfatherwiz bannerwiz says [FAIL] missing package(s); calendarwiz needs it too; examwiz court needs it for its screens (its other commands do not); godfatherwiz prints a plain title
sqlalchemy optional for sqlwiz sqlwiz's database commands say [FAIL] SQLAlchemy not installed
PyYAML optional for privacywiz privacywiz reads its policy file with its own small YAML reader instead

Every wizard's own list is its deps.toml; a wizard without one needs no package.

Programs, only for the commands that use them:

Program Used by For How to get it
git the toolkit cloning the repository; scripts/precommit_check.py; commandlinewiz's suite sudo apt-get install git
ollama codeguardwiz, commandlinewiz, examwiz, godfatherwiz, helpwiz, mode-manifestingwiz, modelfilewiz, ollamawiz every command that asks a local model (the daemon at 127.0.0.1:11434) and at least one model pulled https://ollama.com/download
jq jsonwiz jsonwiz jq only sudo apt-get install jq, or jsonwiz install-jq
lua truthdwiz truthdwiz verify --check lua only sudo apt-get install lua5.4
espeak-ng voicewiz the espeak voice sudo apt-get install espeak-ng
piper voicewiz the Piper voices voicewiz setup piper (installs piper-tts into ~/piper-env; needs the network)
aplay voicewiz playing speech (or paplay, or afplay on macOS) sudo apt-get install alsa-utils
curl commandlinewiz the Ollama check in commandlinewiz's suite sudo apt-get install curl
bash supremewiz shell syntax checks present on Linux
tmux bashwiz bashwiz tmux only (the session commands absorbed from the toolkit's tmuxwiz, D29) sudo apt-get install tmux, or requirementswiz setup bashwiz

The owner's base repository. These wizards were written for the private ~/wizard_central and say so and stop without it:


🚀 Getting started

From a fresh Linux machine (Debian, Ubuntu or Chromebook Linux):

sudo apt-get update
  sudo apt-get install -y git python3 python3-venv
  git clone https://github.com/rewardsbycode-eng/wiz-central-pro-AI-modes-toolkit.git
  cd wiz-central-pro-AI-modes-toolkit
  python3 --version                     # must be 3.12 or newer
  python3 -m venv .venv                 # .venv is in .gitignore
  . .venv/bin/activate                  # again in every new terminal
  

The repository is private: cloning it needs a GitHub account the owner has added as a collaborator.

Then only what you will use (see What you need):

pip install mcp py_landlock pyseccomp      # the MCP bridge and its sandbox wall
  pip install pyfiglet rich click            # bannerwiz and calendarwiz; the screens of examwiz and godfatherwiz
  pip install pytest sqlalchemy PyYAML       # only for supremewiz test, sqlwiz's database commands, privacywiz
  

Run everything from the repository root. A first check, in a few seconds each:

python3 tests/wizard_validation.py   # registry checks
  python3 tests/test_compose.py        # composer, fingerprints, cross-process reproducibility
  python3 tests/test_ported.py         # every ported wizard runs through the registry
  python3 wizards/helpwiz/bin/helpwiz list   # the wizards, from the registry
  

The full test loop runs every test file. On the owner's Chromebook a full loop took 26.5 minutes (2026-10-27); from the second loop on, it prints its own estimate from your machine's history:

python3 scripts/loop.py              # must end: LOOP GREEN (full)
  

For a green loop, install click, rich, py_landlock and pyseccomp first, and mcp for the loop to test the bridge. Measured in a virtual environment with no packages (2026-10-27): without click six test files fail, because calendarwiz crashes; without py_landlock, tests/test_sandbox.py fails (one test does not skip as the others do; not fixed yet); without mcp the bridge's tests say SKIP and the loop can still end green, so a green loop without mcp says nothing about the bridge. Without pyfiglet, bannerwiz's drawing tests say SKIP. What each result means is in docs/TESTING.md.

Compose modes into a system prompt

import sys
  sys.path.insert(0, "src")

  from engine.compose import compose

  result = compose(
      ["privacywiz", "stepwiz", "apijsonwiz"],
      user_query="Summarize this support ticket.",
  )

  print(result.system_prompt)   # one prompt, modes ordered by priority
  print(result.fingerprint)     # SHA-256 of that prompt
  print(result.modes)           # the modes in the order they appear in the prompt
  messages = result.as_messages()   # [{"role": "system", ...}, {"role": "user", ...}]
  

compose() builds the prompt; it does not call a model. You send it with your own chat call.

Higher-priority categories come first, and the prompt tells the model that the mode listed first wins any conflict:

Category Priority
Governance & Safety Guardrails 105
Governance & Safety 100
Reasoning Modes 80
Domain Expertise 60
Specialized AI 50
Output Styles 40
Data & Integration 30
Performance & Scale 10

What is reproducible. The same modes, the same prompt text and the same format version always produce a byte-identical system prompt, whatever order the handles are given in. The tests check this across separate Python processes with different hash seeds, and the saved fingerprints in tests/golden/ make any accidental edit to a mode fail a test.

What is not. This says nothing about what a language model does with the prompt. Model output can vary between runs, and a prompt can steer a model but not force it. Priority order is guidance to the model, not enforcement. No test measures whether a mode changes a model's answers.

Run a ported wizard

From the shell, each wizard is its own program: python3 wizards/<name>/bin/<name> --help. From Python:

from engine.ported import run

  r = run("@gitwiz", ["find", "commit"])   # a subprocess; returns CompletedProcess
  print(r.returncode, r.stdout)
  

Only the wizards in the PORTED table in src/engine/ported.py can be run this way (the list is under The wizards below). A command a wizard marks person-only is refused through the registry: a write needs a human at a terminal. @writewiz runs everything except its consent commands (commit, rollback, discard, purge-old, unprotect). python3 tests/test_ported.py checks them. Every command of every wizard is in docs/COMMANDS.md.

Export the tool wizards

from engine.wiz_modes_registry import (
      get_full_wiz_specs, export_llm_tools,
  )

  specs = get_full_wiz_specs()        # every spec, keyed by handle ("@debugwiz")
  tools = export_llm_tools()          # the 110 roster tools; AI modes are not included
  some_category = next(iter(specs.values())).category
  tools = export_llm_tools(categories=[some_category])   # a smaller list
  

Most of these schemas have no code behind them. The export covers the whole roster, and only the wizards in the PORTED table can run. To give a model only tools that work, use the MCP bridge, which offers only listed commands of ported wizards.

AI modes are instructions, not functions, so the default export leaves them out (include_ai_modes=True adds them). They are registered with deterministic=False, because model output is not deterministic.

Renamed modes. Five modes originally shared a handle with a roster tool wizard, so they were renamed with the same meaning: @chainwiz is now @stepwiz, @legwiz is now @lawwiz, @cachewiz is now @memowiz, @graphqlwiz is now @gqlwiz, @debugwiz is now @rootcausewiz. All 75 entries are registered.

The MCP bridge

mcp/server.py lets an MCP client use the AI modes as prompts and the ported wizards as tools, on this machine (ollmcp is the client verified end to end so far). It needs pip install mcp (version 2), and the wall needs py_landlock and pyseccomp on Linux. @mcpwiz is its settings panel: python3 wizards/mcpwiz/bin/mcpwiz status; python3 mcp/server.py --check says what is installed and what is switched on.

What the tests prove (tests/test_mcp_server.py, tests/test_mcpwiz.py, tests/test_guardrails.py, tests/test_sandbox.py):

What the bridge does not cover: a model that has its own shell, outside the server, is outside the gate. The godfatherwiz REPL's model does not go through the bridge either; it is limited to a fixed list of look-only wizards (see Status), and moving it behind the gate is planned (see Coming).


🧰 The wizards

Generated. Every wizard that runs here. Needs: what it needs beyond Python (packages from its deps.toml, programs, the owner's base repository). MCP tools: commands offered as tools / commands in its mcp.json, when it has one; every tool still needs a person to switch it on. Person only: commands the registry refuses to run for a model or a script.

Wizard What it is Needs MCP tools Person only
@bannerwiz ASCII banner maker: stacked block murals with colour and fusion looks, every FIGlet font, 18 style presets, auto-fit to the terminal, saved profiles and an export of one text in every font. pyfiglet, rich 11 of 18 none
@bashwiz Looks at your shell setup and adds the ll and la aliases to ~/.bashrc or ~/.zshrc. tmux none apply, tmux
@bootstrapwiz The fleet conductor (admission authority): scaffold a new wizard, certify it, register it in the manifest and link it, plus lint, census, verify, retire and amend. ~/wizard_central none new, resume, retire, amend
@calendarwiz Manage past and future events, dates, and schedules. click, rich none none
@codeguardwiz Audits a source file with a local Ollama model and lists what it found; scans folders, filters by severity, explains a line, compares with the last audit and prints a test skeleton. ollama none none
@commandlinewiz Runs declared fleet checks and writes a timestamped census: the shared test suites, git state, the Ollama daemon, and --help for every ported wizard. ollama, curl none run, history, sessions
@daemonwiz Keeps a registry of named background commands: starts and stops them, says whether each is alive (told by pid and start time, so a reused pid is never signalled) and shows what they printed. nothing none register, unregister, start, stop, sweep
@debugwiz Diagnosis oracle for Python code: traceback autopsy, error classification, hotspots, undefined names, missing imports and heuristic fix suggestions. nothing none none
@diffwiz Read-only diffs: unified, context, word-level and summary diffs of two text files, and a tree comparison that skips .git, .venv, pycache and node_modules. nothing 7 of 7 none
@docwiz File and folder toolkit: read, write, append, copy, move, rename, back up and restore, hash, search, tree, head, tail and count lines or words. nothing none write, append, copy, move, delete, mkdir, touch, empty, backup, restore, decode, replace, rename
@dotfilewiz Keeps vault copies of the dot files you choose (.bashrc, .gitconfig, a .config folder), tells you when the live ones drift, shows the difference and puts them back. ~/wizard_central none track, untrack, snapshot, restore, backup
@examwiz Puts a local Ollama model on the bench with a battery of missions and judges each reply against the disk and the battery's expectations: exam lets the machine judge (it decides only what the disk proves or what is clear; the rest is UNVERIFIED), court lets a person rule each reply. rich (optional), ollama 4 of 6 court
@gitwiz Plain-language git manual lookup: print the manual or find a term in it. nothing 2 of 2 none
@godfatherwiz The Grand Master: fleet dispatcher and REPL cockpit. pyfiglet (optional), rich (optional), ollama none repl, run, task, heal, consent, schedule
@grantwiz The front door to mcpwiz's folder grants: list the current grants, check whether a path can be granted, and print the mcpwiz command a person would run. nothing 3 of 5 add, revoke
@helpwiz The fleet's read-only help and guide: a numbered menu, faq, categories, modes, wizard and topics answer from the registry, the wizards' READMEs and the docs with no model; it also lists the citizens, shows and compares their charters, and answers questions with a local Ollama model that is shown only the matching charters, with the charters it saw named after the answer and any command it quoted that is not in them flagged. ollama 10 of 16 none
@jsonwiz Checks, reshapes and compares JSON with named failures (strict: no NaN, no duplicate keys), runs the real jq with the filter as a single argument and a cleared environment, and pulls the JSON out of a model's reply. jq 11 of 13 install-jq
@knowledgewiz The estate's memory keeper: captures lessons and notes from a folder as drafts, lists, shows, searches, tags and exports the knowledge base, and archives entries. nothing none ratify
@manualwiz The documentation auditor: censuses the home folder for projects with a real README, a stub or none, writes ~/MANUAL.md from the documented ones (only over a MANUAL.md it wrote itself), and verifies that every command the manual lists is on disk. ~/wizard_central none none
@mappingwiz Audits the private wizard_central estate for mappings that no longer match reality: dead links in ~/bin, bootstrap records, the README manifest and imports. ~/wizard_central none fix
@mcpwiz Settings and permissions for the MCP bridge: what is switched on, which folders are granted and for how long, the per-tool switches and the receipts log. nothing none on, grant, preset, menu, guard-mode-off, guardrail-off
@mode-manifestingwiz The fleet's universal forge, create-only: survey a REPL, have a local Ollama draft a mode spec, and create new modes, tools, skills and tasks on your own machine. ollama none forge, forge-tool, forge-skill, ratify, retire, mode-approve, mode-revoke, guardrail-approve, guardrail-revoke
@modelfilewiz Governs the Modelfiles a local Ollama serves: lists them, reads them, captures them into ~/.modelfilewiz/sources, reports drift between live and captured, and rebuilds a model from its source. ollama none record, record-all, rebuild
@ollamawiz Looks at the Ollama daemon on this machine: installed models and sizes, what is loaded and how much is on the GPU, digests, a model's card and parameters, a timed question to a model, and which listed tool-calling models fit this device. ollama none stop, enable-catalog, ollama-catalog
@privacyscanwiz Privacy enforcement for a fleet of Python wizards: scans their code for telemetry and analytics libraries, hardcoded secrets and non-allowlisted URLs, audits a whole fleet, keeps a hash-chained audit log, and quarantines a non-compliant wizard. PyYAML (optional), ~/wizard_central none quarantine, unquarantine
@pythonwiz The fleet's syntax gate: compiles (never runs) a Python file or a whole tree and reports the exact error, plus read-only audits (outline, imports, complexity, docstrings, secrets, score and more). nothing 22 of 22 none
@readwiz Read-only verb gate: judges a raw shell command and answers ALLOW or DENIED. nothing 3 of 3 none
@repairwiz The healer for broken Python files: diagnose with the interpreter's own compile(), fix what it names (a missing colon, a bracket never closed or not matching), and STAGE the fix through writewiz. nothing none none
@repl-managerwiz Finds the REPLs in your home folder and reports which of seven doctrine organs each has; can add one organ to a REPL (backup first, checked first) or make a new REPL from a template. nothing none graft, new
@requirementswiz Owns the fleet's dependency truth: scan a wizard's imports, declare them in its deps.toml, aggregate into a fleet requirements.txt, lock installed versions, and verify that every non-stdlib import is declared. py_landlock (optional), pyseccomp (optional) none install, setup
@sqlwiz SQL query builder, migration differ and EXPLAIN analyzer with 15 commands (query, validate, seed, dump, export and more). sqlalchemy (optional) none none
@supremewiz Test runner for a project folder: scans Python, JSON and shell files for syntax errors, runs the project's own pytest suite (all, last failed, failed first, parallel), and keeps text, JSON and HTML reports with a run history in /test_reports/. pytest (optional), bash 13 of 14 clean
@test-admissionwiz DevOps reports with 11 commands: systemd services, listening ports, top processes, disk, network, journal, users, groups and sudo, crontab, uptime and a health summary. nothing 0 of 11 none
@todowiz REPL-facing focus engine: records active work items (task, skill, script, ...) with an optional ref to where the artifact lives, scoped by project. nothing none rm
@truthdwiz The truthd verification daemon's client and server, local only: ping it, ask it to verify that a path exists or that a shipped Lua validator says OK, read its status and log, or list a directory straight from disk. lua none serve
@truthwiz Honest context injector for LLM briefings: real directory listings, file contents, hashes, sizes, symlinks and git state read straight from disk, plus the TRUTH LAW text. nothing 21 of 22 none
@voicewiz The know-it-all of voice setups: knows each speech engine (Piper, espeak-ng), checks what this machine has, walks a person through the setup one confirmed step at a time, lists the Piper voice catalog by language, plans downloads inside a size budget and the free disk, and speaks. espeak-ng, piper, aplay none setup, get, remove, start
@whiteboardwiz The model whiteboard: drafts wait on a board and only a person at a terminal gives consent to ratify them (skill accept and wipe ask y/N and refuse a pipe or the registry; nothing is deleted). nothing none wipe
@writewiz Consent wall for file writes: propose content into quarantine, preview it, and commit only on a live human's 'y' at a terminal, with backups, rollback, protected paths and a journal. nothing none commit, rollback, discard, purge-old, unprotect

🛣️ Coming

Generated. Placeholders for what is designed or decided and not built. None of it works yet; each line is removed when its part is built and tested.

Read from the code:

Decided or designed, not built yet (placeholders; each line goes when it is built and tested):


📁 Layout

wiz-central-pro-AI-modes-toolkit/
  ├── README.md                   # this page; its generated sections come from scripts/gen_readme.py
  ├── src/engine/
  │   ├── wiz_modes_registry.py   # WizardCategory, WizardSpec, WizardRosterRegistry
  │   ├── ai_modes_data.py        # the 75 registry entries: handle, category, description
  │   ├── ai_modes_prompts.py     # the 75 prompts (source of truth)
  │   ├── compose.py              # compose(), fingerprints
  │   ├── custom_modes.py         # your own modes, approved by hash (docs/CUSTOM_MODES.md)
  │   ├── guardrails.py           # your own declarative guard rules, approved by hash
  │   ├── ported.py               # the PORTED table: the 39 wizards that can be run
  │   ├── license.py
  │   └── conductor_certifier.py
  ├── mcp/server.py               # the MCP bridge (needs: pip install mcp)
  ├── wizards/                    # 39 command-line wizards, each with bin/, lib/ and README.md (see wizards/PORTING.md)
  ├── tests/                      # one test file per wizard and per part; scripts/loop.py runs them all
  │   ├── wizard_validation.py
  │   └── golden/compose.json     # reference fingerprints
  ├── scripts/
  │   ├── loop.py                 # the full test loop
  │   ├── precommit_check.py      # the commit check: what is staged is what was tested
  │   ├── facts.py                # every number the docs state, counted from the code
  │   ├── gen_readme.py           # writes the generated sections of this README
  │   ├── gen_modes_doc.py        # regenerates docs/MODES.md
  │   ├── gen_commands_doc.py     # regenerates docs/COMMANDS.md
  │   ├── gen_mcp_manifests.py    # writes the wizards' mcp.json files
  │   ├── sandbox_*.py            # the wall around bridge calls
  │   ├── (port_, fix_, add_)*.py # hash-guarded change scripts, kept as the record of each change
  │   └── one-time/               # scripts that have already been run
  └── docs/                       # below
  
docs/
  ├── AI_MODES_USAGE.md       # how to use the AI modes, with examples
  ├── ARCHITECTURE.md         # the parts and how a request flows
  ├── BASE_ROSTER.md          # every wizard in the base `wizard_central` and its Pro name
  ├── COMMANDS.md             # generated: every wizard command
  ├── CUSTOM_MODES.md         # your own AI modes, approved by hash
  ├── FLAKES.md               # tests that failed once, and how they are judged
  ├── GRANTS_AND_RECEIPTS.md  # folder grants, records grants (designed), the receipts log
  ├── GUARD_MODES.md          # the guard modes: what each refuses, and your own rules
  ├── MANIFESTS.md            # `mcp.json`: which commands are tools, and their classes
  ├── MCP_STATUS.md           # the bridge: what is verified, what is not, how to check
  ├── MODES.md                # generated: every mode and its prompt
  ├── SANDBOX.md              # the wall around every bridge call
  ├── TESTING.md              # the loop, the commit check, what each result means
  ├── USAGE.md                # usage examples; every Python example is run by `tests/test_usage_docs.py`
  └── archive/                # done or replaced: WIZMODES-original.md, voicewiz_port_plan.md
  

✏️ Changing a mode

  1. Edit its text in src/engine/ai_modes_prompts.py.
  2. python3 scripts/gen_modes_doc.py
  3. python3 tests/test_compose.py --update-golden
  4. python3 scripts/loop.py, then commit.

If you skip step 2 or 3, a test fails. That is intentional.

🔄 When the code changes

python3 scripts/gen_readme.py rewrites this README's generated sections; --check only says which are out of date. The loop does not rewrite files while it tests them: it goes red, names the command, and you run it and look at the diff. The data the generator cannot read from the code (each status row's state, the programs, the placeholders under Coming, a line for each docs page) is at the top of scripts/gen_readme.py, and the test fails when that data no longer matches the code.

🔐 Licensing data

beta_keys.json and certified_users.json are listed in .gitignore and are never committed.

This is the project's README as published in its repository.

MathSphere Nexus official corporate seal