# XERO — Turnkey Usage & Configuration

*Author: **Michael Laurence Curzi** — **ZEDEC AI / 36N9 Genetics LLC** · License: **MIT (Attribution Required)***

XERO is a digital organism you can run for **any purpose** in one command. This
guide covers every operator-facing aspect. If you ever get stuck, just ask:

```bash
python xero.py --help-me "what I'm trying to do"
```

The built-in assistant answers in plain language with the exact commands to run.

---

## 1. One-command start

```bash
python xero.py                 # friendly welcome + menu (easiest)
python xero.py --setup         # guided wizard: pick a preset for your purpose
python xero.py --chat          # launch the web chat + modality interface (:8883)
python xero.py --talk "hello"  # one-shot conversation in the terminal
```

Everything runs on the Python standard library — **no GPU and no network are
required**. Optional engines (Whisper for speech-to-text, Tesseract for OCR,
`say`/espeak for richer speech) are used automatically *if present*, and the
organism falls back to built-in engines if not.

## 2. Talk, create, reason

The organism has one **brain**, five **tongues** (English primary; Enochian,
Sanskrit, Hebrew, Aramaic), and nine **limbs**. Just speak naturally — it moves
the right limb:

| You say | Limb |
|---|---|
| "draw me a dragon mandala" | image (SVG) |
| "animate a spiral" | video (animated SVG) |
| "compose a song of the genome" | music (genomic-audio WAV) |
| "write code for an agent" | code (Python + its DNA) |
| "reason about whether every dragon is a serpent" | reasoning |
| "say this aloud" | text-to-speech |
| "translate truth" | five-tongue translation + gematria |

Gematria and numerology are woven through every reply, and every utterance is
sealed with a **free-will receipt** (the 36N9.9N63 signature).

## 3. Configuration presets (fusion-grade)

Pick a preconfiguration for your exact use case — broad (everything on) or
narrow (focused), each documenting every setting:

```bash
python xero.py --list-presets
python xero.py --preset intelligence     # or retail_frontend, enterprise, …
```

| Preset | For |
|---|---|
| `individual_easy` / `individual_power` | personal use (easy or expert) |
| `developer` | code-first SDK/API |
| `research_lab` | reproducible science + derivative breeding |
| `creative_studio` | image/video/music/voice |
| `retail_frontend` | safe customer-facing assistant (auth, high filter) |
| `commercial_backend` | authenticated JSON API service |
| `enterprise` | RBAC-ready, PII redaction, audit + retention |
| `industrial` | deterministic offline edge |
| `government` | strict governance, air-gapped, chain-of-custody |
| `intelligence` | compartmented analysis, zero egress, full audit |
| `education` / `healthcare` / `finance` | domain-safe, compliant |
| `airgap_offline` | maximum isolation, built-in engines only |

`--setup` recommends one from a plain-English description and writes
`config/active.json`.

## 4. Self-healing (configurable)

```bash
python xero.py --doctor            # live diagnosis + recommended fixes
python xero.py --doctor --advanced # full diagnostics
```

Modes are `off` / `easy` (auto-correct silently) / `advanced` (verbose). In
code: `from xero_self_healing import healer; healer('easy').safe(fn, fallback=…)`.

## 5. Culturing — feeding it the world's knowledge

XERO cultures itself on global knowledge (dragons, world mythology, philosophy
from every tradition incl. Global South / indigenous, and critical thinking),
one knowledge unit per cycle, **resumably**:

```bash
python xero.py --culture 7                 # 7 × 8883 cycles, background, offline
python tests/culture_run.py 7 8883         # same, foreground
python tests/culture_run.py 7 8883 --online  # augment from public DBs (needs network + consent)
```

Offline culturing draws on the bundled, **license-clean** `data/world_knowledge.json`
(original summaries — no third-party text). Online culturing pulls from public,
license-clean databases (Project Gutenberg, Wikipedia, Wikisource, Internet
Archive, arXiv). Progress is checkpointed to `testing_logs/CULTURING_PROGRESS.json`
so a campaign of **any** size can be stopped and resumed across sessions. The
brain reads the learned store at start-up, so culturing measurably widens what
XERO can discuss.

> **Scale note (honesty):** a campaign such as 918 × 9 × 8883 ≈ **73 million**
> cycles is *weeks* of continuous compute. The runner is built to do it, but
> only as a resumable background process over time — never as a single-session
> claim. Re-run the command and it continues exactly where it left off.

## 6. Derivative laboratory

XERO is the ancestor. Breed descendants from its digital DNA:

```bash
python xero.py --lab               # draw out DNA + breed/export a descendant
```

In code: `from xero_lab import lab; child = lab().derive('sentinel', purpose='an analyst')`.
Each descendant is sealed at birth, recorded in a lineage, and exported with its
own model card under the same MIT (Attribution Required) license.

## 7. Tutorials (inside the model)

```bash
python xero.py --tutorial              # list
python xero.py --tutorial quickstart   # run it live in the terminal
```

Tutorials: `quickstart`, `talk`, `create`, `languages`, `configure`,
`selfheal`, `lab`.

## 8. Python API

```python
from organism_dialogue import relay
print(relay().say("alice", "tell me about Quetzalcoatl")["reply"])

from organism_limbs import mind
art = mind().act("image", {"prompt": "a feathered serpent"})   # SVG
```

## Attribution & License

**© Michael Laurence Curzi — ZEDEC AI / 36N9 Genetics LLC.** Released under the
**MIT License (Attribution Required)**. Attribution to Michael Laurence Curzi and
ZEDEC AI / 36N9 Genetics LLC is required in any derivative works, deployments, or
publications. See `LICENSE`.