omnius 1.0.2 → 1.0.3

package/README.md

@@ -28,7 +28,7 @@
 ---
 
 ```bash
-npm i -g omnius && oa
+npm i -g omnius && omnius
 ```
 
 An autonomous multi-turn tool-calling agent that reads your code, makes changes, runs tests, and fixes failures in an iterative loop until the task is complete. First launch auto-detects your hardware and configures the optimal model with expanded context window automatically.
@@ -59,7 +59,7 @@ An autonomous multi-turn tool-calling agent that reads your code, makes changes,
     - [Parallelism & Concurrency](#parallelism--concurrency)
     - [Endpoint Reference](#endpoint-reference)
     - [Stateful Chat — `/v1/chat` + `/api/chat` (OpenAI drop-in with full agent under the hood)](#stateful-chat--v1chat--apichat-openai-drop-in-with-full-agent-under-the-hood)
-    - [Live Comparison: Ollama vs OA Full Agent](#live-comparison-ollama-vs-oa-full-agent)
+    - [Live Comparison: Ollama vs Omnius Full Agent](#live-comparison-ollama-vs-omnius-full-agent)
     - [One-Off Completions — `/api/generate` + `/v1/generate`](#one-off-completions--apigenerate--v1generate)
     - [Embeddings — `/v1/embeddings` + `/api/embed`](#embeddings--v1embeddings--apiembed)
     - [Memory Recall + Knowledge Graph — `/v1/memory/*`](#memory-recall--knowledge-graph--v1memory)
@@ -212,7 +212,7 @@ An autonomous multi-turn tool-calling agent that reads your code, makes changes,
 - [Configuration](#configuration)
   - [Network Access & Binding](#network-access--binding)
   - [Project Context](#project-context)
-  - [`.oa/` Project Directory](#oa-project-directory)
+  - [`.omnius/` Project Directory](#omnius-project-directory)
 - [Model Support](#model-support)
 - [Supported Inference Providers](#supported-inference-providers)
   - [Connecting to a Provider](#connecting-to-a-provider)
@@ -242,7 +242,7 @@ An LLM is a high-bandwidth associative generative core — closer to a cortex-li
 |---|---|---|
 | Associative core | Cortex | LLM weights (any size) |
 | Current workspace | Global workspace / attention | `assembleContext()` — structured context assembly |
-| Episodic memory | Hippocampus | `.oa/memory/` — write, search, retrieve across sessions |
+| Episodic memory | Hippocampus | `.omnius/memory/` — write, search, retrieve across sessions |
 | Cognitive map | Hippocampal spatial maps | `semantic-map.ts` + `repo-map.ts` (PageRank) |
 | Action gating | Basal ganglia | Tool selection policy (task-aware filtering) |
 | Temporal hierarchy | Prefrontal executive | Task decomposition, sub-agent delegation |
@@ -260,7 +260,7 @@ Don't chase larger models. Build the organism around whatever model you have.
 <div align="right"><a href="#top">back to top</a></div>
 
 ```
-You: oa "fix the null check in auth.ts"
+You: omnius "fix the null check in auth.ts"
 
 Agent: [Turn 1] file_read(src/auth.ts)
        [Turn 2] grep_search(pattern="null", path="src/auth.ts")
@@ -286,8 +286,8 @@ The agent uses tools autonomously in a loop — reading errors, fixing code, and
 - **Sub-agent delegation** — spawn independent agents for parallel workstreams
 - **OpenCode delegation** — offload coding tasks to opencode (sst/opencode) as an autonomous sub-agent with auto-install, progress monitoring, and result evaluation
 - **Long-horizon cron agents** — schedule recurring autonomous agent tasks with goals, completion criteria, execution history, and automatic evaluation (daily code reviews, weekly dep updates, continuous monitoring)
-- **Nexus P2P networking** — decentralized agent-to-agent communication via [omnius-nexus](https://www.npmjs.com/package/omnius-nexus). Join rooms, discover peers, share resources, and communicate across the agent mesh with encrypted P2P transport
-- **x402 micropayments** — native x402 payment rails via omnius-nexus@1.5.6. Agents create secp256k1/EVM wallets (AES-256-GCM encrypted, keys never exposed to LLM), register inference with USDC pricing on Base, auto-handle `payment_required`/`payment_proof` negotiation, track earnings/spending in ledger.jsonl, enforce budget policies, and sign gasless EIP-3009 transfers
+- **Nexus P2P networking** — decentralized agent-to-agent communication via [open-agents-nexus](https://www.npmjs.com/package/open-agents-nexus). Join rooms, discover peers, share resources, and communicate across the agent mesh with encrypted P2P transport
+- **x402 micropayments** — native x402 payment rails via open-agents-nexus@1.5.6. Agents create secp256k1/EVM wallets (AES-256-GCM encrypted, keys never exposed to LLM), register inference with USDC pricing on Base, auto-handle `payment_required`/`payment_proof` negotiation, track earnings/spending in ledger.jsonl, enforce budget policies, and sign gasless EIP-3009 transfers
 - **Inference capability proof** — benchmark local models with anti-spoofing SHA-256 hashed proofs, generate capability scorecards for peer verification
 - **Littleman Observer** — parallel meta-analysis system that watches the agent loop in real-time. Detects false failure claims after successful tools, blocks redundant re-execution, catches runaway one-sided output in conversations, and dynamically extends turn limits when active work is detected. Emits `debug_context` and `debug_littleman` events for live observability
 - **Interactive Session Lock** — generic `SESSION_ACTIVE` protocol prevents premature task completion during long-running sessions (phone calls, live chat, monitoring). Any MCP contract can adopt the protocol. Paired with context-engineered system prompts that teach small models to maintain conversation loops
@@ -306,8 +306,8 @@ Omnius includes background workers that compute and associate embeddings across
 
 Config (env vars):
 
-- `OA_COOCUR_WINDOW_MS` — max time delta between visual and transcript episodes to create co‑occurrence links (default: 120000 ms).
-- `OA_COOCUR_CLIP_SIM_MIN` — minimum CLIP text↔image cosine (0..1, default: 0.22) for linking when both embeddings are available.
+- `OMNIUS_COOCUR_WINDOW_MS` — max time delta between visual and transcript episodes to create co‑occurrence links (default: 120000 ms).
+- `OMNIUS_COOCUR_CLIP_SIM_MIN` — minimum CLIP text↔image cosine (0..1, default: 0.22) for linking when both embeddings are available.
 
 The daemon auto-installs Python dependencies (OpenCLIP, torchaudio + soundfile, speechbrain, Whisper) into `~/.omnius/venv` and registers providers automatically. No manual installs are required.
 - **Ralph Loop** — iterative task execution that keeps retrying until completion criteria are met
@@ -316,7 +316,7 @@ The daemon auto-installs Python dependencies (OpenCLIP, torchaudio + soundfile,
 - **Persistent Python REPL** — `repl_exec` tool maintains variables, imports, and functions across calls. Write Python code that processes data iteratively, with `llm_query()` available for recursive LLM sub-calls from within code
 - **Recursive LLM calls** — `llm_query(prompt, context)` invokes the model from inside REPL code, enabling loop-based semantic analysis of large inputs ([RLM paper](https://arxiv.org/abs/2512.24601)). `parallel_llm_query()` runs multiple calls concurrently ([SPRINT](https://arxiv.org/abs/2506.05745))
 - **Memory metabolism** — governed memory lifecycle: classify (episodic/semantic/procedural/normative), score (novelty/utility/confidence), consolidate lessons from trajectories. Inspired by [TIMG](https://arxiv.org/abs/2603.10600) and [MemMA](https://arxiv.org/abs/2603.18718)
-- **Identity kernel** — persistent self-state with continuity register, homeostasis estimation, relationship models, and version lineage. Persists across sessions in `.oa/identity/`
+- **Identity kernel** — persistent self-state with continuity register, homeostasis estimation, relationship models, and version lineage. Persists across sessions in `.omnius/identity/`
 - **Reflection & integrity** — immune-system audit: diagnostic ("what's wrong?"), epistemic ("what evidence is missing?"), constitutional ("should this change become part of self?"). Inspired by [LEAFE](https://arxiv.org/abs/2603.16843) and [RewardHackingAgents](https://arxiv.org/abs/2603.11337)
 - **Exploration & culture** — ARCHE strategy-space exploration: generate competing hypotheses, archive successful variants, retrieve past strategies. Inspired by [SGE](https://arxiv.org/abs/2603.02045) and [Darwin Gödel Machine](https://arxiv.org/abs/2505.22954)
 - **Autoresearch Swarm** — 5-agent GPU experiment loop during REM sleep: Researcher, Monitor, Evaluator, Critic, Flow Maintainer autonomously run ML training experiments, keep improvements, discard regressions
@@ -325,7 +325,7 @@ The daemon auto-installs Python dependencies (OpenCLIP, torchaudio + soundfile,
 - **Call Sub-Agent** — each WebSocket caller gets a dedicated AgenticRunner for low-latency voice-to-voice loops, with admin/public access tiers and bidirectional activity sharing with the main agent
 - **Telegram Voice** — `/voice` enabled via Telegram forwards TTS audio as voice messages alongside text responses. Incoming voice messages are auto-transcribed and handled as text
 - **Neural TTS** — hear what the agent is doing via GLaDOS, Overwatch, Kokoro, or LuxTTS voice clone, with literature-grounded narration engine (sNeuron-TST structure rotation, Moshi ring buffer dedup, UDDETTS emotion-driven prosody, SEST metadata, LuxTTS flow-matching voice cloning)
-- **Supertonic expressive tags** — when `/voice supertonic` is active, OA inserts supported expression tags such as `<sigh>`, `<breath>`, and `<laugh>` into spoken status updates based on failure, recovery, sentence boundaries, success, and playful tone. Other voice backends receive sanitized plain text
+- **Supertonic expressive tags** — when `/voice supertonic` is active, Omnius inserts supported expression tags such as `<sigh>`, `<breath>`, and `<laugh>` into spoken status updates based on failure, recovery, sentence boundaries, success, and playful tone. Other voice backends receive sanitized plain text
 - **Personality Core** — SAC framework-based style control (concise/balanced/verbose/pedagogical) that shapes agent response depth, voice expressiveness, and system prompt behavior
 - **Human expert speed ratio** — real-time `Exp: Nx` gauge comparing agent speed to a leading human expert, calibrated across 47 tool baselines
 - **Cost tracking** — real-time token cost estimation for 15+ cloud providers
@@ -342,14 +342,14 @@ The daemon auto-installs Python dependencies (OpenCLIP, torchaudio + soundfile,
 - **Inference capability scoring** — canirun.ai-style hardware assessment at first launch: memory/compute/speed scores, per-model compatibility matrix, recommended model selection
 - **Auto-install everything** — first-run wizard auto-installs Ollama, curl, Python3, python3-venv with platform-aware package managers (apt, dnf, yum, pacman, apk, zypper, brew)
 - **Sponsored inference** — `/sponsor` walks through a 5-step wizard to share your GPU with the world: select endpoints, choose banner animation (8 presets + AI-generated custom), set header message/links, configure transport (cloudflared/libp2p) + rate limits, and go live. Consumers discover sponsors via `/endpoint sponsor`. Secure proxy relay with per-IP rate limiting, daily token budgets, model allowlist, and concurrent request caps. Sponsor's raw API URL is never exposed. See [Sponsored Inference](#sponsored-inference--share-your-gpu-with-the-world) below
-- **P2P inference network** — `/expose` local models or forward any `/endpoint` (Chutes, Groq, OpenRouter, etc.) through the libp2p P2P mesh. Passthrough mode (`/expose passthrough`) relays upstream API requests; `--loadbalance` distributes rate-limited token budgets across peers. `/expose config` provides an arrow-key menu for all settings. Gateway stats show budget remaining from `x-ratelimit-*` headers. Background daemon persists across OA restarts
-- **P2P mesh networking** — `/p2p` with secret-safe variable placeholders (`{{OA_VAR_*}}`), trust tiers (LOCAL/TEE/VERIFIED/PUBLIC), WebSocket peer mesh, and inference routing with automatic secret redaction/injection
+- **P2P inference network** — `/expose` local models or forward any `/endpoint` (Chutes, Groq, OpenRouter, etc.) through the libp2p P2P mesh. Passthrough mode (`/expose passthrough`) relays upstream API requests; `--loadbalance` distributes rate-limited token budgets across peers. `/expose config` provides an arrow-key menu for all settings. Gateway stats show budget remaining from `x-ratelimit-*` headers. Background daemon persists across Omnius restarts
+- **P2P mesh networking** — `/p2p` with secret-safe variable placeholders (`{{OMNIUS_VAR_*}}`), trust tiers (LOCAL/TEE/VERIFIED/PUBLIC), WebSocket peer mesh, and inference routing with automatic secret redaction/injection
 - **Secret vault** — `/secrets` manages API keys and credentials with AES-256-GCM encrypted persistence; secrets are automatically redacted before sending to untrusted inference peers and re-injected on response
 - **Auto-expanding context** — detects RAM/VRAM and creates an optimized model variant on first run
 - **Mid-task steering** — type while the agent works to add context without interrupting
 - **Smart compaction** — 6 context compaction strategies (default, aggressive, decisions, errors, summary, structured) with ARC-inspired active context revision ([arXiv:2601.12030](https://arxiv.org/abs/2601.12030)) that preserves structural file content through compaction, preventing small-model repetitive loops at the root cause. Success signals and content previews survive compaction so models never lose evidence that tools succeeded
 - **Memex experience archive** — large tool outputs archived during compaction with hash-based retrieval
-- **Persistent memory** — learned patterns stored in `.oa/memory/` across sessions
+- **Persistent memory** — learned patterns stored in `.omnius/memory/` across sessions
 - **Structured procedural memory (SQLite)** — replaces flat JSON with a full relational database: CRUD with soft-delete, revision tracking, embedding storage (float32 BLOB), bidirectional memory linking with confidence scores. Inspired by [ExpeL](https://arxiv.org/abs/2308.10144) (contrastive extraction) and [TIMG](https://arxiv.org/abs/2603.10600) (structured procedural format). 79 unit tests
 - **Semantic memory search** — vector embeddings via [Ollama /api/embed](https://ollama.com) (nomic-embed-text, 768-dim) with cosine similarity search over stored memories. Auto-generates embeddings on memory creation. Auto-links related memories when similarity > 0.6. Graceful fallback to text search when Ollama unavailable
 - **LLM-based memory extraction** — post-task, the LLM itself extracts structured procedural memories (CATEGORY/TRIGGER/LESSON/STEPS) instead of copying raw error text verbatim. Based on [ExpeL](https://arxiv.org/abs/2308.10144) and [AWM](https://arxiv.org/abs/2409.07429) patterns
@@ -357,13 +357,13 @@ The daemon auto-installs Python dependencies (OpenCLIP, torchaudio + soundfile,
 - **IPFS sharing surface** — `/ipfs` status page with peer info + identity kernel metrics + memory sentiment. `/ipfs pin <CID>` to pin remote agent content. `/ipfs publish` to share identity kernel. `/ipfs share tool/skill` to publish agent-created tools with secret stripping. `/ipfs import <CID>` to retrieve shared content
 - **Fortemi-React bridge** — `/fortemi start/status/stop` connects to [fortemi-react](https://github.com/robit-man/fortemi-react) (browser-first PGlite+pgvector knowledge system) via JWT auth. Proxy tools: `fortemi_capture`, `fortemi_search`, `fortemi_list`, `fortemi_get` auto-register when bridge is connected
 - **Content ingestion** — `/ingest <file>` imports audio (transcribe via Whisper), PDF (pdftotext), or text files into structured memory with 800-char/100-overlap chunking (matches fortemi pattern)
-- **Image generation** — `generate_image` tool using Ollama experimental models ([x/z-image-turbo](https://ollama.com/x/z-image-turbo), [x/flux2-klein](https://ollama.com/x/flux2-klein)). Auto-detect or auto-pull models. Saves PNG to `.oa/images/`
-- **Node visualization** — [openagents.nexus](https://github.com/robit-man/openagents.nexus) Three.js dashboard: 5-color emotional state mapping (neutral/focused/stressed/dreaming/excited), dynamic node size by memory depth + IPFS storage, activity-modulated connections, identity synchrony golden threads between mutually-pinned agents
+- **Image generation** — `generate_image` tool using Ollama experimental models ([x/z-image-turbo](https://ollama.com/x/z-image-turbo), [x/flux2-klein](https://ollama.com/x/flux2-klein)). Auto-detect or auto-pull models. Saves PNG to `.omnius/images/`
+- **Node visualization** — [omnius.nexus](https://github.com/robit-man/omnius.nexus) Three.js dashboard: 5-color emotional state mapping (neutral/focused/stressed/dreaming/excited), dynamic node size by memory depth + IPFS storage, activity-modulated connections, identity synchrony golden threads between mutually-pinned agents
 - **TTS sanitizer** — strips markdown syntax (`##`, `**`, `` ` ``), emoji (prevents "white heavy checkmark"), box-drawing chars, and ANSI codes before feeding to ALL TTS engines
 - **LuxTTS gapless playback** — look-ahead pre-synthesis pipeline: next chunk synthesizes while current plays, eliminating inter-sentence gaps. Jetson ARM support with NVIDIA's prebuilt PyTorch wheel
 - **Unified color scheme** — `ui.primary` (252), `ui.error` (198/magenta), `ui.warn` (214/orange), `ui.accent` (178/yellow) applied consistently across all TUI surfaces
 - **Clickable header buttons** — `help`, `voice`, `cohere`, `model` buttons on banner row 3 with hover/click visual states. OSC 8 hyperlinks for pointer cursor. Mouse click fires the slash command directly
-- **Dynamic terminal title** — updates with current task + version: `"fix auth bug · OA v0.141.0"`
+- **Dynamic terminal title** — updates with current task + version: `"fix auth bug · Omnius v0.141.0"`
 - **Session context persistence** — auto-saves context on task completion, manual `/context save|restore` across sessions
 - **Self-learning** — auto-fetches docs from the web when encountering unfamiliar APIs
 - **Seamless `/update`** — in-place update and reload with automatic context save/restore
@@ -412,20 +412,20 @@ Run Omnius as a headless service for CI/CD pipelines, automation, and enterprise
 ### Non-Interactive Mode
 
 ```bash
-oa "fix all lint errors" --non-interactive    # Run task, exit when done
-oa "generate API docs" --json                 # Structured JSON output (no ANSI)
-oa "run security audit" --background          # Detached background job
+omnius "fix all lint errors" --non-interactive    # Run task, exit when done
+omnius "generate API docs" --json                 # Structured JSON output (no ANSI)
+omnius "run security audit" --background          # Detached background job
 ```
 
 ### Background Jobs
 
 ```bash
-oa "migrate database" --background            # Returns job ID immediately
-oa status job-abc123                          # Check job progress
-oa jobs                                       # List all running/completed jobs
+omnius "migrate database" --background            # Returns job ID immediately
+omnius status job-abc123                          # Check job progress
+omnius jobs                                       # List all running/completed jobs
 ```
 
-Jobs run as detached processes — survive terminal disconnection. Output saved to `.oa/jobs/{id}.json`.
+Jobs run as detached processes — survive terminal disconnection. Output saved to `.omnius/jobs/{id}.json`.
 
 ### JSON Output Mode
 
@@ -441,15 +441,15 @@ Pipe to `jq`, ingest into monitoring systems, or feed to other agents.
 ### Process Management
 
 ```bash
-/destroy processes              # Kill orphaned OA processes (local project)
-/destroy processes --global     # Kill ALL orphaned OA processes system-wide
+/destroy processes              # Kill orphaned Omnius processes (local project)
+/destroy processes --global     # Kill ALL orphaned Omnius processes system-wide
 ```
 
-Shows per-process RAM and CPU usage before killing. Detects: cloudflared tunnels, nexus daemons, headless Chrome, TTS servers, Python REPLs, stale OA instances.
+Shows per-process RAM and CPU usage before killing. Detects: cloudflared tunnels, nexus daemons, headless Chrome, TTS servers, Python REPLs, stale Omnius instances.
 
 ### REST API Service (Port 11435)
 
-Omnius runs a persistent enterprise-grade REST API on `127.0.0.1:11435` — installed automatically by `npm i -g omnius` (systemd user unit on Linux, launchd on macOS, scheduled task on Windows). It exposes the **full OA capability surface** through standards most organizations expect:
+Omnius runs a persistent enterprise-grade REST API on `127.0.0.1:11435` — installed automatically by `npm i -g omnius` (systemd user unit on Linux, launchd on macOS, scheduled task on Windows). It exposes the **full Omnius capability surface** through standards most organizations expect:
 
 - **OpenAI / Ollama drop-in** — `/v1/chat`, `/v1/chat/completions`, `/v1/embeddings`, `/v1/models` are wire-compatible with both ecosystems
 - **API discovery** — `GET /help` returns a full human and agent-readable guide with quickstart curl commands, all 70+ endpoints by category, MCP integration instructions, and auth documentation
@@ -464,19 +464,19 @@ Omnius runs a persistent enterprise-grade REST API on `127.0.0.1:11435` — inst
 - **`X-Request-ID`** echoed or generated for correlation
 - **SSE event bus** at `/v1/events` with optional `?type=foo.*` filter, tagged with `aims:control` for auditors
 - **Bearer auth + scoped keys** (`read` / `run` / `admin`) and OIDC JWT support
-- **Per-key concurrency limits** (`maxJobs` in `OA_API_KEYS` is now actually enforced)
+- **Per-key concurrency limits** (`maxJobs` in `OMNIUS_API_KEYS` is now actually enforced)
 - **Atomic job record writes** with 64-bit job IDs (no race conditions)
 - **OpenAPI 3.0** at `/openapi.json` and Swagger UI at `/docs`
 - **Web chat UI** at `/`
 
-> **Daemon auto-start.** After `npm i -g omnius`, the daemon comes online automatically. Verify with `systemctl --user status omnius-daemon` (Linux) or `launchctl print gui/$(id -u)/ai.omnius.daemon` (macOS). Opt out with `OA_SKIP_DAEMON_INSTALL=1 npm i -g omnius`.
+> **Daemon auto-start.** After `npm i -g omnius`, the daemon comes online automatically. Verify with `systemctl --user status omnius-daemon` (Linux) or `launchctl print gui/$(id -u)/ai.omnius.daemon` (macOS). Opt out with `OMNIUS_SKIP_DAEMON_INSTALL=1 npm i -g omnius`.
 
 ```bash
 # Manually run the server (the daemon already does this for you)
-oa serve                                              # Start on default port 11435
-oa serve --port 9999                                  # Custom port
-OA_API_KEY=mysecret oa serve                          # Single admin key
-OA_API_KEYS="key1:admin:alice:30:50000:5,key2:run:ci:60::3,key3:read:grafana" oa serve  # Scoped multi-key with rpm:tpd:maxjobs
+omnius serve                                              # Start on default port 11435
+omnius serve --port 9999                                  # Custom port
+OMNIUS_API_KEY=mysecret omnius serve                          # Single admin key
+OMNIUS_API_KEYS="key1:admin:alice:30:50000:5,key2:run:ci:60::3,key3:read:grafana" omnius serve  # Scoped multi-key with rpm:tpd:maxjobs
 ```
 
 > **Every example below is verified against `omnius@0.187.189` on a live daemon.** Examples from earlier versions are deprecated.
@@ -486,7 +486,7 @@ OA_API_KEYS="key1:admin:alice:30:50000:5,key2:run:ci:60::3,key3:read:grafana" oa
 Control who can reach the daemon and where it binds:
 
 - TUI commands: `/access loopback|lan|any`, `/host <host[:port]>`, `/network config` (interactive), `--local` to save per‑project.
-- Environment: `OA_ACCESS=loopback|lan|any`, `OA_HOST=host[:port]`.
+- Environment: `OMNIUS_ACCESS=loopback|lan|any`, `OMNIUS_HOST=host[:port]`.
 - See Configuration → [Network Access & Binding](#network-access--binding) for full details and security guidance.
 
 #### Working Directory
@@ -534,12 +534,12 @@ curl http://localhost:11435/version
 curl http://localhost:11435/metrics
 ```
 ```
-# HELP oa_requests_total Total HTTP requests
-# TYPE oa_requests_total counter
-oa_requests_total{method="POST",path="/v1/chat/completions",status="200"} 47
-oa_tokens_in_total 12450
-oa_tokens_out_total 8230
-oa_errors_total 0
+# HELP omnius_requests_total Total HTTP requests
+# TYPE omnius_requests_total counter
+omnius_requests_total{method="POST",path="/v1/chat/completions",status="200"} 47
+omnius_tokens_in_total 12450
+omnius_tokens_out_total 8230
+omnius_errors_total 0
 ```
 
 #### OpenAI-Compatible Inference
@@ -592,7 +592,7 @@ data: [DONE]
 
 #### Agentic Task Execution
 
-The unique OA capability — submit a coding task and get an autonomous agent loop.
+The unique Omnius capability — submit a coding task and get an autonomous agent loop.
 
 ```bash
 # Run task in your current directory
@@ -730,7 +730,7 @@ curl -X POST http://localhost:11435/v1/commands/destroy \
 
 ```bash
 # Multi-key setup: read (monitoring), run (CI), admin (ops)
-OA_API_KEYS="grafana-key:read:grafana,ci-key:run:github-actions,ops-key:admin:ops-team" oa serve
+OMNIUS_API_KEYS="grafana-key:read:grafana,ci-key:run:github-actions,ops-key:admin:ops-team" omnius serve
 ```
 
 | Scope | Can do | Cannot do |
@@ -830,21 +830,21 @@ curl -X DELETE -H "Authorization: Bearer $ADMIN_KEY" \
 
 The daemon is built for **unbounded concurrent requests** with per-key enforcement. Every agentic task (`/v1/run`, `/v1/chat`, `/api/chat`, `/api/generate`) spawns its own subprocess, so multiple jobs run in true parallel — same model or different models, same or different profiles, same or different sandbox modes.
 
-**Per-key concurrency limits** are enforced from the `OA_API_KEYS` env var:
+**Per-key concurrency limits** are enforced from the `OMNIUS_API_KEYS` env var:
 
 ```bash
 # key:scope:user:rpm:tpd:maxJobs
-OA_API_KEYS="ci-key:run:github-actions:60:100000:5, \
+OMNIUS_API_KEYS="ci-key:run:github-actions:60:100000:5, \
              ops-key:admin:ops:120:500000:20, \
              read-key:read:grafana:600::"
-oa serve
+omnius serve
 ```
 
 The 6th field is `maxJobs` — the maximum number of **concurrent** (in-flight) agentic tasks for that key. When exceeded, the daemon returns **RFC 7807 `429 Too Many Requests`**:
 
 ```json
 {
-  "type": "https://openagents.nexus/problems/rate-limited",
+  "type": "https://omnius.nexus/problems/rate-limited",
   "title": "Concurrent job limit exceeded",
   "status": 429,
   "detail": "Concurrent job limit exceeded for github-actions: 5/5",
@@ -871,7 +871,7 @@ done
 wait
 ```
 
-Each subprocess inherits a **clean env** — `OA_DAEMON` and `OA_PORT` are explicitly stripped so the child doesn't re-enter daemon mode. Fixed in v0.187.189 (root cause of the earlier "Task incomplete (0 turns, 0 tool calls)" bug).
+Each subprocess inherits a **clean env** — `OMNIUS_DAEMON` and `OMNIUS_PORT` are explicitly stripped so the child doesn't re-enter daemon mode. Fixed in v0.187.189 (root cause of the earlier "Task incomplete (0 turns, 0 tool calls)" bug).
 
 **Observing parallelism live** — subscribe to the event bus to watch every job lifecycle event:
 
@@ -932,7 +932,7 @@ Also cleans up the Docker container if the job was spawned with `"sandbox":"cont
 | Method | Path | Auth | Description |
 |--------|------|------|-------------|
 | POST | `/v1/chat` | run | Full agent under the hood, OpenAI chat.completion shape. Default = tools=true (subprocess agent). Set `tools:false` for direct backend bypass. Supports `timeout_s` body field (default 180s). Non-streaming path has a safety SIGTERM→SIGKILL after `timeout_s + 30s`. |
-| POST | `/api/chat` | run | **Ollama-compatible alias** — same handler as `/v1/chat`. Accepts both OA-shape (`{message, model}`) and Ollama-shape (`{model, messages: [...]}`) bodies. Returns OpenAI `chat.completion` shape on success and failure (failure uses `finish_reason:"error"`). |
+| POST | `/api/chat` | run | **Ollama-compatible alias** — same handler as `/v1/chat`. Accepts both Omnius-shape (`{message, model}`) and Ollama-shape (`{model, messages: [...]}`) bodies. Returns OpenAI `chat.completion` shape on success and failure (failure uses `finish_reason:"error"`). |
 | POST | `/v1/generate` | run | **One-off completion** — same agent stack as `/v1/chat` but no session history. Returns Ollama-shape `{model, response, done, total_duration}`. |
 | POST | `/api/generate` | run | **Ollama-compatible alias** of `/v1/generate`. Drop-in for Ollama `/api/generate`. |
 | GET | `/v1/chat/sessions` | read | List active chat sessions |
@@ -999,7 +999,7 @@ Also cleans up the Docker container if the job was spawned with `"sandbox":"cont
 **Sessions + context**
 | Method | Path | Auth | Description |
 |--------|------|------|-------------|
-| GET | `/v1/sessions` | read | OA task session archive |
+| GET | `/v1/sessions` | read | Omnius task session archive |
 | GET | `/v1/sessions/:id` | read | Session history |
 | GET | `/v1/context` | read | Show current session context |
 | POST | `/v1/context/save` | run | Save a context entry |
@@ -1066,15 +1066,15 @@ The chat endpoint is mounted at **two paths on port 11435**:
 
 | Path | Purpose |
 |------|---------|
-| `POST /v1/chat` | OA-native path |
+| `POST /v1/chat` | Omnius-native path |
 | `POST /api/chat` | **Ollama-compatible alias** — same handler, so clients pointing at Ollama can be flipped over by changing only the port (`11434` → `11435`) |
 
-It's a **drop-in replacement for OpenAI `/v1/chat/completions` and Ollama `/api/chat`**. The endpoint runs the full OA agent (tools, multi-agent, memory, skills) under the hood and returns an **OpenAI `chat.completion`-shaped response** so any client SDK can use it without modification.
+It's a **drop-in replacement for OpenAI `/v1/chat/completions` and Ollama `/api/chat`**. The endpoint runs the full Omnius agent (tools, multi-agent, memory, skills) under the hood and returns an **OpenAI `chat.completion`-shaped response** so any client SDK can use it without modification.
 
 **Both body shapes are accepted** on either path:
 
 ```jsonc
-// OA-native
+// Omnius-native
 {"message": "hello", "model": "qwen3.5:9b", "stream": false}
 
 // Ollama-native (the `messages` array; the last user message is extracted)
@@ -1082,18 +1082,18 @@ It's a **drop-in replacement for OpenAI `/v1/chat/completions` and Ollama `/api/
 ```
 
 > **Two execution modes:**
-> - **Default (`tools` unset or `tools: true`)** — full agent: spawns the OA subprocess with the entire 82-tool set, runs the agent loop, returns the final answer with `tool_calls` metadata.
+> - **Default (`tools` unset or `tools: true`)** — full agent: spawns the Omnius subprocess with the entire 82-tool set, runs the agent loop, returns the final answer with `tool_calls` metadata.
 > - **Direct (`tools: false`)** — fast path: bypasses the agent and forwards straight to the configured backend (Ollama/vLLM) using the session history. Useful for plain chat without tools.
 
 **Safety timeout** — every non-streaming request is bounded by `timeout_s` (default **180s**). If the agent subprocess doesn't close in `timeout_s + 30s`, the daemon SIGTERMs (then SIGKILLs) it and returns an OpenAI-shaped error with `finish_reason:"error"` and a clear explanation. No more hung requests.
 
-**Flip Ollama → OA by port alone** — this is verified to work via `scripts/oa-vs-ollama-chat-compare.sh` (see [Live Comparison](#live-comparison-ollama-vs-oa-full-agent) below):
+**Flip Ollama → Omnius by port alone** — this is verified to work via `scripts/omnius-vs-ollama-chat-compare.sh` (see [Live Comparison](#live-comparison-ollama-vs-omnius-full-agent) below):
 
 ```bash
 # Before (Ollama)
 curl -s http://127.0.0.1:11434/api/chat -d '{"model":"qwen3.5:9b","messages":[{"role":"user","content":"hi"}],"stream":false}'
 
-# After (OA with full agent) — only port changed
+# After (Omnius with full agent) — only port changed
 curl -s http://127.0.0.1:11435/api/chat -d '{"model":"qwen3.5:9b","messages":[{"role":"user","content":"hi"}],"stream":false}'
 ```
 
@@ -1197,32 +1197,32 @@ curl -s http://localhost:11435/v1/chat \
 
 Sessions expire after 30 minutes of inactivity. List active sessions: `GET /v1/chat/sessions`.
 
-#### Live Comparison: Ollama vs OA Full Agent
+#### Live Comparison: Ollama vs Omnius Full Agent
 
-The repo ships a reproducible side-by-side harness at [`scripts/oa-vs-ollama-chat-compare.sh`](scripts/oa-vs-ollama-chat-compare.sh). It runs **5 tool-call-required prompts** × **4 phases** (Ollama non-stream, OA non-stream, Ollama stream, OA stream) = **20 runs per invocation** with the same model and the same `/api/chat` path on both ports.
+The repo ships a reproducible side-by-side harness at [`scripts/omnius-vs-ollama-chat-compare.sh`](scripts/omnius-vs-ollama-chat-compare.sh). It runs **5 tool-call-required prompts** × **4 phases** (Ollama non-stream, Omnius non-stream, Ollama stream, Omnius stream) = **20 runs per invocation** with the same model and the same `/api/chat` path on both ports.
 
 ```bash
-MODEL=qwen3.5:9b bash scripts/oa-vs-ollama-chat-compare.sh
+MODEL=qwen3.5:9b bash scripts/omnius-vs-ollama-chat-compare.sh
 ```
 
 **Results from `omnius@0.187.191` with `qwen3.5:9b`** (all 20 runs completed, zero timeouts):
 
 | # | Prompt | Ollama (bare) | Omnius (full agent) | Winner |
 |---|---|---|---|---|
-| 1 | "Latest stable Node.js version + source URL" | ❌ **v22.10.0** — hallucinated from Aug-2024 training cutoff | ✅ **v25.9.0** fetched from `nodejs.org/download/current`, **3 tool calls** (`web_search` → `web_fetch` → `task_complete`) | **OA** |
-| 2 | "Biggest tech news this week + source URL" | ❌ "I don't have real-time access" + generic AI trend guess | ✅ **Anthropic Mythos, Intel Terafab, Apple foldable, Russian router breach, Firmus $5.5B** — sourced from TechCrunch, **4 tool calls** | **OA** |
-| 3 | "Current OS, CPU cores, free memory — use shell tools" | ❌ Confabulated **"Linux / 8 cores / 6.1 GB"** (all wrong) | ✅ **Ubuntu 24.04.2 / 48 cores / 120 GB** (all correct), **6–7 shell tool calls** | **OA** |
-| 4 | "List files in cwd, count top level, most recent" | ❌ "I cannot access your filesystem" | ✅ **20 files, 50+ dirs, `.claude.json` (81 KB, 09:09 UTC)** via `list_directory`, **2 tool calls** | **OA** |
-| 5 | "2022 FIFA World Cup final winner + score" (both endpoints have this in training data) | ✅ Argentina 4–2 France | ✅ Argentina 3–3 France, **4–2 on penalties at Lusail Stadium, Dec 18 2022** — grounded with 4 tool calls | **Tie (OA more detailed)** |
+| 1 | "Latest stable Node.js version + source URL" | ❌ **v22.10.0** — hallucinated from Aug-2024 training cutoff | ✅ **v25.9.0** fetched from `nodejs.org/download/current`, **3 tool calls** (`web_search` → `web_fetch` → `task_complete`) | **Omnius** |
+| 2 | "Biggest tech news this week + source URL" | ❌ "I don't have real-time access" + generic AI trend guess | ✅ **Anthropic Mythos, Intel Terafab, Apple foldable, Russian router breach, Firmus $5.5B** — sourced from TechCrunch, **4 tool calls** | **Omnius** |
+| 3 | "Current OS, CPU cores, free memory — use shell tools" | ❌ Confabulated **"Linux / 8 cores / 6.1 GB"** (all wrong) | ✅ **Ubuntu 24.04.2 / 48 cores / 120 GB** (all correct), **6–7 shell tool calls** | **Omnius** |
+| 4 | "List files in cwd, count top level, most recent" | ❌ "I cannot access your filesystem" | ✅ **20 files, 50+ dirs, `.claude.json` (81 KB, 09:09 UTC)** via `list_directory`, **2 tool calls** | **Omnius** |
+| 5 | "2022 FIFA World Cup final winner + score" (both endpoints have this in training data) | ✅ Argentina 4–2 France | ✅ Argentina 3–3 France, **4–2 on penalties at Lusail Stadium, Dec 18 2022** — grounded with 4 tool calls | **Tie (Omnius more detailed)** |
 
 **Latency profile** (wall clock, 5-prompt median):
 
-| Phase | Ollama | OA agent | OA overhead |
+| Phase | Ollama | Omnius agent | Omnius overhead |
 |---|---|---|---|
 | Non-streaming | 12–18s | 24–42s | 12–26s (agent loop + tool calls) |
 | Streaming SSE | 11–16s | 24–56s | 10–40s |
 
-**Streaming parser validation** — every OA stream delivered:
+**Streaming parser validation** — every Omnius stream delivered:
 - Live intermediate `tool_call` events mid-stream (e.g. `['web_search', 'web_fetch', 'task_complete']`)
 - OpenAI `chat.completion.chunk` deltas with `id`, `model`, `finish_reason`
 - Clean `data: [DONE]` termination with `finish_reason:"stop"`
@@ -1230,12 +1230,12 @@ MODEL=qwen3.5:9b bash scripts/oa-vs-ollama-chat-compare.sh
 The harness is **reproducible** — rerun it after any `/v1/chat` change to catch regressions:
 
 ```bash
-MODEL=qwen3.5:4b bash scripts/oa-vs-ollama-chat-compare.sh       # faster tier for quick smoke
-MODEL=qwen3.5:9b OA_TIMEOUT=300 bash scripts/oa-vs-ollama-chat-compare.sh   # default
-MODEL=qwen3.5:32b OA_TIMEOUT=600 bash scripts/oa-vs-ollama-chat-compare.sh  # higher tier
+MODEL=qwen3.5:4b bash scripts/omnius-vs-ollama-chat-compare.sh       # faster tier for quick smoke
+MODEL=qwen3.5:9b OMNIUS_TIMEOUT=300 bash scripts/omnius-vs-ollama-chat-compare.sh   # default
+MODEL=qwen3.5:32b OMNIUS_TIMEOUT=600 bash scripts/omnius-vs-ollama-chat-compare.sh  # higher tier
 ```
 
-**Bottom line**: for any question that needs fresh data, system access, or filesystem visibility — bare Ollama is wrong or refuses; OA with the full agent is correct with citations. That's the differentiator captured live in the harness output.
+**Bottom line**: for any question that needs fresh data, system access, or filesystem visibility — bare Ollama is wrong or refuses; Omnius with the full agent is correct with citations. That's the differentiator captured live in the harness output.
 
 #### One-Off Completions — `/api/generate` + `/v1/generate`
 
@@ -1246,11 +1246,11 @@ Drop-in for **Ollama `/api/generate`**. Same body shape, same response shape, sa
 curl -s http://127.0.0.1:11434/api/generate \
   -d '{"model":"qwen3.5:9b","prompt":"Name 3 open-source databases.","stream":false}'
 
-# OA with full agent — only port changed
+# Omnius with full agent — only port changed
 curl -s http://127.0.0.1:11435/api/generate \
   -d '{"model":"qwen3.5:9b","prompt":"Name 3 open-source databases.","stream":false}'
 
-# OA direct backend bypass (fast path, no agent)
+# Omnius direct backend bypass (fast path, no agent)
 curl -s http://127.0.0.1:11435/api/generate \
   -d '{"model":"qwen3.5:9b","prompt":"Name 3 open-source databases.","stream":false,"tools":false}'
 ```
@@ -1275,7 +1275,7 @@ curl -s http://127.0.0.1:11435/api/generate \
 }
 ```
 
-The `_oa` extension block carries the OA-specific metadata (tool call count, agent duration, request ID for correlation with `/v1/audit`). Strict Ollama clients ignore unknown fields — no client changes required.
+The `_oa` extension block carries the Omnius-specific metadata (tool call count, agent duration, request ID for correlation with `/v1/audit`). Strict Ollama clients ignore unknown fields — no client changes required.
 
 **Streaming** — set `"stream": true` and receive Ollama-style NDJSON chunks:
 
@@ -1351,18 +1351,18 @@ The `strength` and `lastRetrieved` fields are updated on every search — the st
 
 #### Generate/Embed/Memory Test Harness
 
-A second harness at [`scripts/oa-vs-ollama-generate-embed-memory.sh`](scripts/oa-vs-ollama-generate-embed-memory.sh) covers the four non-chat endpoint families:
+A second harness at [`scripts/omnius-vs-ollama-generate-embed-memory.sh`](scripts/omnius-vs-ollama-generate-embed-memory.sh) covers the four non-chat endpoint families:
 
 ```bash
 MODEL=qwen3.5:9b EMBED_MODEL=nomic-embed-text \
-  bash scripts/oa-vs-ollama-generate-embed-memory.sh
+  bash scripts/omnius-vs-ollama-generate-embed-memory.sh
 ```
 
 **Tested results from `omnius@0.187.195`** (live, single run, `qwen3.5:9b` + `nomic-embed-text`):
 
 **Part 1 — `/api/generate` one-off prompts**:
 
-| Prompt | Ollama | OA direct | OA full agent |
+| Prompt | Ollama | Omnius direct | Omnius full agent |
 |---|---|---|---|
 | "TCP vs UDP in one sentence" | 26.8s — correct | 12.5s — correct | 43.8s — correct, **1 tool call** |
 | "One-line Python square function" | 32.1s — correct | 12.2s — correct | ~3min — correct, **2 tool calls** |
@@ -1370,7 +1370,7 @@ MODEL=qwen3.5:9b EMBED_MODEL=nomic-embed-text \
 
 **Part 2 — `/api/embed` cosine similarity sanity** (4 test sentences):
 
-Both Ollama and OA emitted **identical 768-dim vectors** (same backend). Cosine similarity matrix:
+Both Ollama and Omnius emitted **identical 768-dim vectors** (same backend). Cosine similarity matrix:
 
 ```
                    France→Par  Paris→Fran  Germany→Be   Bananas
@@ -1620,7 +1620,7 @@ curl -s -X POST http://localhost:11435/v1/files/read \
 #### Sessions, Context, Cost, Sponsors, Nexus
 
 ```bash
-# OA task session archive (not chat sessions)
+# Omnius task session archive (not chat sessions)
 curl -s 'http://localhost:11435/v1/sessions?limit=10'
 curl -s http://localhost:11435/v1/sessions/{session_id}
 
@@ -1653,7 +1653,7 @@ curl -s -X POST http://localhost:11435/v1/files/read -d '{}'
 ```
 ```json
 {
-  "type": "https://openagents.nexus/problems/invalid-request",
+  "type": "https://omnius.nexus/problems/invalid-request",
   "title": "Missing 'path'",
   "status": 400,
   "detail": "POST body must include {path: string, offset?: number, limit?: number}",
@@ -1697,7 +1697,7 @@ curl -s -o /dev/null -w '%{http_code}\n' \
 
 #### Web Interface
 
-Open `http://localhost:11435/` in a browser when `oa serve` is running. Zero external dependencies — single self-contained HTML page.
+Open `http://localhost:11435/` in a browser when `omnius serve` is running. Zero external dependencies — single self-contained HTML page.
 
 **Tabs:**
 - **Chat** — Conversational interface using `/v1/chat` with full tool access, session persistence, streaming responses, and collapsible tool call dropdowns
@@ -1718,7 +1718,7 @@ Open `http://localhost:11435/` in a browser when `oa serve` is running. Zero ext
 - Token counter per conversation
 - Conversation export (Markdown or JSON)
 - GPU/VRAM detection with model compatibility recommendations
-- Per-provider token tracking (persisted to `.oa/usage/token-usage.json`)
+- Per-provider token tracking (persisted to `.omnius/usage/token-usage.json`)
 
 ### Enterprise Licensing
 
@@ -1797,16 +1797,16 @@ SUGGESTED NEXT STEP: A completed todo claims a missing artifact...
 Prior `<world-state>` blocks are stripped before injecting the freshest one — only the current snapshot lives in context. Plan reconciliation uses `verifyCommand` + `declaredArtifacts` from the todo store + heuristic filename matching. Disk scan is gitignore-aware, capped at 200 files. Generic across stacks.
 *Lit anchors*: MetaGPT (Hong et al. ICLR 2024) — SOP-encoded state representation; AlphaCodium (Pinto 2024) — symbol-aware iteration.
 
-Configurable via `OA_WORLD_STATE_INTERVAL` (default 8), `OA_WORLD_STATE_FILE_WRITE_THRESHOLD` (default 5), `OA_WORLD_STATE_MAX_FILES` (default 200).
+Configurable via `OMNIUS_WORLD_STATE_INTERVAL` (default 8), `OMNIUS_WORLD_STATE_FILE_WRITE_THRESHOLD` (default 5), `OMNIUS_WORLD_STATE_MAX_FILES` (default 200).
 
 ### REG-47 — Backward-pass critic on `task_complete`
 
-When the agent calls `task_complete` AND ≥ 1 file mutation occurred AND `OA_BACKWARD_PASS=on`, the orchestrator spawns a dedicated CRITIC sub-agent against the same backend. The critic gets the diff + plan reconciliation + recent failures + a 10-point structural audit checklist (dead refs, missing imports, off-by-one, null-handling, stateful regex, hardcoded paths, untested code paths, plan-disk gaps, unresolved failures, generic-vs-specific drift) and votes:
+When the agent calls `task_complete` AND ≥ 1 file mutation occurred AND `OMNIUS_BACKWARD_PASS=on`, the orchestrator spawns a dedicated CRITIC sub-agent against the same backend. The critic gets the diff + plan reconciliation + recent failures + a 10-point structural audit checklist (dead refs, missing imports, off-by-one, null-handling, stateful regex, hardcoded paths, untested code paths, plan-disk gaps, unresolved failures, generic-vs-specific drift) and votes:
 - **approve** → task_complete proceeds, run terminates
 - **request_changes** → issue feedback injected as a system message; agent loops to address
 - **reject** → critical event; same as request_changes but with escalation marker
 
-Cycle-bounded (default 2 cycles before fail-soft). Default OFF — explicit opt-in via `OA_BACKWARD_PASS=on`.
+Cycle-bounded (default 2 cycles before fail-soft). Default OFF — explicit opt-in via `OMNIUS_BACKWARD_PASS=on`.
 *Lit anchors*: Self-Refine (Madaan et al. NeurIPS 2024) — +6-12% HumanEval correctness from a dedicated reviewer; CodeT (Chen et al. arxiv 2306.03907) — critic-contested implementer claims.
 
 ### REG-48 — Cross-file specification drift detection
@@ -1861,29 +1861,29 @@ Run-by-run progression of the orchestrator:
 | #18 | 43/44/45/46/47 | killed @ ~30m, 8/9 phases done, test-debug stuck | 62 | ✓ | partial |
 | **#19** | **43/44/45/46/47/48** | **completed cleanly** | **62** | **✓** | **6/6 pass** |
 
-Detailed archival report: [`.aiwg/oa-eval/RESULTS-RUN-19.md`](.aiwg/oa-eval/RESULTS-RUN-19.md).
+Detailed archival report: [`.aiwg/omnius-eval/RESULTS-RUN-19.md`](.aiwg/omnius-eval/RESULTS-RUN-19.md).
 
 ### Configuration summary
 
 ```bash
 # Defense activation (set in daemon env or systemd unit)
-OA_BACKWARD_PASS=on                   # enable REG-47 critic (default: off)
-OA_BACKWARD_PASS_MAX_CYCLES=2         # max review iterations
-OA_BACKWARD_PASS_MIN_WRITES=1         # min file mutations to trigger review
-OA_BACKWARD_PASS_TIMEOUT_MS=120000    # critic call timeout
-OA_BACKWARD_PASS_MAX_TOKENS=4096      # critic response cap
-OA_BACKWARD_PASS_MAX_FILES=60         # max files in critic prompt
-OA_BACKWARD_PASS_MAX_FILE_PREVIEW=8000
+OMNIUS_BACKWARD_PASS=on                   # enable REG-47 critic (default: off)
+OMNIUS_BACKWARD_PASS_MAX_CYCLES=2         # max review iterations
+OMNIUS_BACKWARD_PASS_MIN_WRITES=1         # min file mutations to trigger review
+OMNIUS_BACKWARD_PASS_TIMEOUT_MS=120000    # critic call timeout
+OMNIUS_BACKWARD_PASS_MAX_TOKENS=4096      # critic response cap
+OMNIUS_BACKWARD_PASS_MAX_FILES=60         # max files in critic prompt
+OMNIUS_BACKWARD_PASS_MAX_FILE_PREVIEW=8000
 
-OA_WORLD_STATE_INTERVAL=8             # REG-46 turn-cadence (default: 8)
-OA_WORLD_STATE_FILE_WRITE_THRESHOLD=5 # REG-46 write-trigger (default: 5)
-OA_WORLD_STATE_MAX_FILES=200          # REG-46 disk-scan cap
+OMNIUS_WORLD_STATE_INTERVAL=8             # REG-46 turn-cadence (default: 8)
+OMNIUS_WORLD_STATE_FILE_WRITE_THRESHOLD=5 # REG-46 write-trigger (default: 5)
+OMNIUS_WORLD_STATE_MAX_FILES=200          # REG-46 disk-scan cap
 
-OA_WORLD_STATE_DRIFT=on               # REG-48 drift detector (default: on)
-OA_DRIFT_ALIASES='{"~/":"src/"}'      # extra path aliases (JSON)
+OMNIUS_WORLD_STATE_DRIFT=on               # REG-48 drift detector (default: on)
+OMNIUS_DRIFT_ALIASES='{"~/":"src/"}'      # extra path aliases (JSON)
 
-OA_RUN_RETENTION_H=24                 # run-record GC (default: 24h, 0 disables)
-OA_TOOL_OVERRIDES='{"shell":{"off_device_allowed":true}}'  # per-tool security overrides
+OMNIUS_RUN_RETENTION_H=24                 # run-record GC (default: 24h, 0 disables)
+OMNIUS_TOOL_OVERRIDES='{"shell":{"off_device_allowed":true}}'  # per-tool security overrides
 ```
 
 
@@ -1999,7 +1999,7 @@ Omnius builds and maintains a **persistent, auto-updating knowledge graph** of t
 ### How It Works
 
 ```
-Source files  ──>  Regex symbol extraction  ──>  SQLite graph DB (.oa/index/code-graph.db)
+Source files  ──>  Regex symbol extraction  ──>  SQLite graph DB (.omnius/index/code-graph.db)
      |                                                    |
      |  fs.watch() + debounce ──>  File hash check  ──>  Incremental re-index (per file)
      |                                                    |
@@ -2033,7 +2033,7 @@ For 1M+ LOC codebases, the Louvain community compression reduces 50K+ symbols in
 
 ### Storage
 
-The graph persists in `.oa/index/code-graph.db` (SQLite with WAL mode) across sessions. Incremental updates mean editing a single file costs <50ms regardless of codebase size.
+The graph persists in `.omnius/index/code-graph.db` (SQLite with WAL mode) across sessions. Incremental updates mean editing a single file costs <50ms regardless of codebase size.
 
 ### Research Basis
 
@@ -2144,7 +2144,7 @@ On startup and `/model` switch, Omnius detects your RAM/VRAM and creates an opti
 | **COHERE Cognitive Stack** | |
 | `repl_exec` | Persistent Python REPL — variables/imports persist between calls, `llm_query()` and `parallel_llm_query()` available for recursive LLM invocation, `retrieve()` for handle access |
 | `memory_metabolize` | Governed memory lifecycle — classify (episodic/semantic/procedural/normative), score (novelty/utility/confidence/identity_relevance), consolidate lessons from trajectories |
-| `identity_kernel` | Persistent identity state — hydrate, observe events, propose updates with justification, publish snapshot, reconcile contradictions. Persists in `.oa/identity/` |
+| `identity_kernel` | Persistent identity state — hydrate, observe events, propose updates with justification, publish snapshot, reconcile contradictions. Persists in `.omnius/identity/` |
 | `reflect` | Immune-system reflection — diagnostic (find flaws), epistemic (identify missing evidence), constitutional (review self-updates). Returns pass/revise/block verdict |
 | `explore` | ARCHE strategy-space exploration — generate diverse strategies, archive successful variants with tags/confidence, compare competing approaches, retrieve past strategies |
 | **Hardware Access** | |
@@ -2269,7 +2269,7 @@ Instead of writing custom integrations, point Omnius at an MCP server and its to
 }
 ```
 
-Save that as `.oa/mcp.json` (project) or `~/.omnius/mcp.json` (global). On startup, every server is spawned, the handshake runs, and every tool it advertises is exposed under the namespace `mcp__<server>__<tool>` — selectable by the agent like any built-in.
+Save that as `.omnius/mcp.json` (project) or `~/.omnius/mcp.json` (global). On startup, every server is spawned, the handshake runs, and every tool it advertises is exposed under the namespace `mcp__<server>__<tool>` — selectable by the agent like any built-in.
 
 ### Spec compliance — what we implement
 
@@ -2289,9 +2289,9 @@ The transport layer lives in `packages/execution/src/mcp/transport.ts`; the clie
 
 ### Three ways to add a server
 
-**1. Edit `.oa/mcp.json` directly** — drop in the JSON shape above. On next launch the server is spawned and connected automatically.
+**1. Edit `.omnius/mcp.json` directly** — drop in the JSON shape above. On next launch the server is spawned and connected automatically.
 
-**2. Drag-and-drop a markdown file** — drop any README that contains an MCP config block (Claude Desktop format, bare server JSON, or `npx -y @scope/server-foo` install instructions in a code block) onto the OA terminal. The MD parser detects the configuration with confidence scoring, persists it to `.oa/mcp.json`, and connects immediately. No restart needed. Implementation: `packages/execution/src/mcp/md-intake.ts`.
+**2. Drag-and-drop a markdown file** — drop any README that contains an MCP config block (Claude Desktop format, bare server JSON, or `npx -y @scope/server-foo` install instructions in a code block) onto the Omnius terminal. The MD parser detects the configuration with confidence scoring, persists it to `.omnius/mcp.json`, and connects immediately. No restart needed. Implementation: `packages/execution/src/mcp/md-intake.ts`.
 
 **3. Use the `/mcp` slash command** — interactive TUI registry browser:
 
@@ -2299,7 +2299,7 @@ The transport layer lives in `packages/execution/src/mcp/transport.ts`; the clie
 /mcp                # Open the MCP registry menu
 /mcp status         # Quick connection table
 /mcp ls             # Same as status
-/mcp reload         # Reconnect every server from .oa/mcp.json
+/mcp reload         # Reconnect every server from .omnius/mcp.json
 ```
 
 The main menu lists every configured server with status (●), transport type, tool count, and any error. Selecting a server opens a detail view showing every advertised tool with its description, plus actions to **Edit**, **Reconnect**, **Delete**, or go **Back**. Edit accepts a one-line JSON config; Save returns to the main list with the updated server reconnected.
@@ -2329,7 +2329,7 @@ We test the streaming features end-to-end against the [official everything refer
 
 ### Programmatic API
 
-If you want to drive an MCP server directly from code (instead of through an agent), the OA package re-exports the client:
+If you want to drive an MCP server directly from code (instead of through an agent), the Omnius package re-exports the client:
 
 ```typescript
 import { McpClient } from "omnius";
@@ -2403,7 +2403,7 @@ The loop tracks iteration history, generates completion reports saved to `.aiwg/
 | `/pause` | **Gentle halt** — lets the current inference turn finish, then stops before the next turn. No new tool calls or inference will begin until `/resume`. |
 | `/stop` | **Immediate kill** — aborts the current inference mid-stream, saves task state for later resumption. |
 | `/resume` | **Continue** — resumes a paused or stopped task from where it left off. Also resumes tasks saved by `/stop` or interrupted by `/update`. |
-| `/destroy` | **Nuclear option** — aborts any active task, deletes the `.oa/` directory, clears the console, and exits to shell. |
+| `/destroy` | **Nuclear option** — aborts any active task, deletes the `.omnius/` directory, clears the console, and exits to shell. |
 
 ### Session Context Persistence
 
@@ -2415,13 +2415,13 @@ Context is automatically saved on every task completion and preserved across `/u
 /context show      # Show saved context status (entries, last saved)
 ```
 
-The system maintains a rolling window of the last 20 session entries in `.oa/context/session-context.json`. When you run `/context restore`, the last 10 entries are formatted into a restore prompt and injected into your next task, giving the agent continuity across sessions.
+The system maintains a rolling window of the last 20 session entries in `.omnius/context/session-context.json`. When you run `/context restore`, the last 10 entries are formatted into a restore prompt and injected into your next task, giving the agent continuity across sessions.
 
 During `/update`, context is automatically saved before the process restarts and restored when the new version resumes your task.
 
 ### Auto-Restore on Startup
 
-When you launch `oa` in a workspace that has saved session context from a previous run, you'll be prompted to restore it:
+When you launch `omnius` in a workspace that has saved session context from a previous run, you'll be prompted to restore it:
 
 ```
 ℹ Previous session found (5 entries, last active 2h ago)
@@ -2464,7 +2464,7 @@ Daemon:  COHERE enabled — listening on nexus.cohere.query
          Capacity announcement: 3 models, warm=qwen3.5:122b
 
 Peer:    "Explain TCP vs UDP" → NATS broadcast
-Your OA: claim → route to qwen3:4b (trivial) → respond in 1.2s
+Your Omnius: claim → route to qwen3:4b (trivial) → respond in 1.2s
 ```
 
 **How it works:**
@@ -2475,7 +2475,7 @@ Your OA: claim → route to qwen3:4b (trivial) → respond in 1.2s
 - **Model allowlist** — `/cohere allow qwen3:4b` controls which models are exposed
 - **Ollama safety** — remote queries can ONLY run inference on existing models; `/api/pull`, `/api/delete`, `/api/create` are never called
 - **Identity pinning** — snapshots published to IPFS (Helia) with SHA-256 content addressing; survives daemon restarts
-- **Background daemon** persists across OA restarts (`detached: true` + PID file reconnection)
+- **Background daemon** persists across Omnius restarts (`detached: true` + PID file reconnection)
 
 ```bash
 /cohere stats    # Network transparency — queries in/out, model usage, peer activity
@@ -2525,7 +2525,7 @@ The identity kernel maintains a persistent self-model across sessions, the refle
 
 Omnius includes a behavioral immune system that prevents the agent from making pattern-matched mistakes under pressure. Inspired by biological immune systems: constraints are the antibodies, pressure detection is the inflammatory response, and memory injection is the recall mechanism.
 
-### Constraint Enforcement (`.oa/constraints.json`)
+### Constraint Enforcement (`.omnius/constraints.json`)
 
 Machine-readable rules checked **before every tool execution**:
 
@@ -2550,7 +2550,7 @@ Machine-readable rules checked **before every tool execution**:
 | `warn` | Executes tool but emits warning in agent's next turn context |
 | `log` | Silent recording to audit log, no interruption |
 
-Constraints are scoped: global (`~/.omnius/constraints.json`), project (`.oa/constraints.json`), or session (ephemeral).
+Constraints are scoped: global (`~/.omnius/constraints.json`), project (`.omnius/constraints.json`), or session (ephemeral).
 
 ### Pressure-Aware Decision Gate
 
@@ -2642,7 +2642,7 @@ Use deep context for:
 - Long debugging sessions where error context from earlier is critical
 - Tasks where the agent needs to reason about patterns across many files
 
-The setting persists to `.oa/settings.json`. Deep context is particularly valuable for models with 64K+ context windows (Qwen3.5-122B, Llama 3.1 70B, etc.) where the default thresholds were leaving significant capacity unused.
+The setting persists to `.omnius/settings.json`. Deep context is particularly valuable for models with 64K+ context windows (Qwen3.5-122B, Llama 3.1 70B, etc.) where the default thresholds were leaving significant capacity unused.
 
 ### Status Bar Context Tracking (`Ctx:` + `SNR:`)
 
@@ -2752,7 +2752,7 @@ The profile is compiled into a system prompt suffix (max 80 tokens) injected at
 
 ### Persistence
 
-The style is saved to `.oa/settings.json` (with `--local`) or `~/.omnius/config.json` (global) and persists across sessions. Change it anytime with `/style <preset>` — takes effect on the next task.
+The style is saved to `.omnius/settings.json` (with `--local`) or `~/.omnius/config.json` (global) and persists across sessions. Change it anytime with `/style <preset>` — takes effect on the next task.
 
 ### Research Provenance
 
@@ -2878,7 +2878,7 @@ Output: 48kHz WAV, compatible with Telegram voice messages and WebSocket streami
 
 ### Supertonic Expressive Tags
 
-When Supertonic is the active voice backend, OA decorates spoken status updates with the expression tags Supertonic supports. The tag pass runs after markdown/ANSI cleanup and only for Supertonic, so GLaDOS, Overwatch, Kokoro, and LuxTTS continue receiving plain sanitized text.
+When Supertonic is the active voice backend, Omnius decorates spoken status updates with the expression tags Supertonic supports. The tag pass runs after markdown/ANSI cleanup and only for Supertonic, so GLaDOS, Overwatch, Kokoro, and LuxTTS continue receiving plain sanitized text.
 
 Tag placement is context-aware:
 
@@ -3086,7 +3086,7 @@ When combined with `/voice`, you get full bidirectional audio — speak your tas
 
 The `transcribe-cli` dependency auto-installs in the background on first use. On ARM or when transcribe-cli fails, the system automatically falls back to `openai-whisper` via a self-managed Python venv (same approach used by Moondream vision).
 
-**File transcription**: Drag-and-drop audio/video files (`.mp3`, `.wav`, `.mp4`, `.mkv`, etc.) onto the terminal to transcribe them. Results are saved to `.oa/transcripts/`.
+**File transcription**: Drag-and-drop audio/video files (`.mp3`, `.wav`, `.mp4`, `.mkv`, etc.) onto the terminal to transcribe them. Results are saved to `.omnius/transcripts/`.
 
 
 
@@ -3235,7 +3235,7 @@ Agent: agenda()
 
 | Decision | Research Basis | Key Finding |
 |----------|---------------|-------------|
-| Separate directive store (`.oa/scheduled/`, not `.oa/memory/`) | SSGM ([arXiv:2603.11768](https://arxiv.org/abs/2603.11768), 2026) | Directives in summarizable memory corrupt via compaction — semantic drift degrades scheduling data |
+| Separate directive store (`.omnius/scheduled/`, not `.omnius/memory/`) | SSGM ([arXiv:2603.11768](https://arxiv.org/abs/2603.11768), 2026) | Directives in summarizable memory corrupt via compaction — semantic drift degrades scheduling data |
 | File-based persistence survives process death | MemGPT/Letta (Packer et al. 2023, [arXiv:2310.08560](https://arxiv.org/abs/2310.08560)) | Agents are ephemeral; state must be external to the process |
 | Priority-based startup surfacing | A-MAC ([arXiv:2603.04549](https://arxiv.org/abs/2603.04549), 2026) | 5-factor attention scoring; content type prior is most influential factor (31% latency reduction) |
 | Cross-session self-reflection | Reflexion (Shinn et al. 2023, [arXiv:2303.11366](https://arxiv.org/abs/2303.11366)) | Persistent self-reflection stored as text improves task success 20-30% |
@@ -3289,7 +3289,7 @@ Supports `apt` (Debian/Ubuntu), `dnf` (Fedora), `pacman` (Arch), and `brew` (mac
 Launch without arguments to enter the interactive REPL:
 
 ```bash
-oa
+omnius
 ```
 
 The TUI features an animated multilingual phrase carousel, live metrics bar with pastel-colored labels (token in/out, context window usage, human expert speed ratio, cost), rotating tips, syntax-highlighted tool output, and dynamic terminal-width cropping.
@@ -3308,9 +3308,9 @@ The TUI features an animated multilingual phrase carousel, live metrics bar with
 | `/pause` | Pause after current turn finishes (gentle halt) |
 | `/stop` | Kill current inference immediately, save state |
 | `/resume` | Resume a paused or stopped task |
-| `/destroy` | Remove `.oa/` folder, kill all tasks, clear console, exit |
+| `/destroy` | Remove `.omnius/` folder, kill all tasks, clear console, exit |
 | **Context & Memory** | |
-| `/context save` | Force-save session context to `.oa/context/` |
+| `/context save` | Force-save session context to `.omnius/context/` |
 | `/context restore` | Restore context from previous sessions into next task |
 | `/context show` | Show saved session context status |
 | `/compact` | Force context compaction now (default strategy) |
@@ -3383,7 +3383,7 @@ The TUI features an animated multilingual phrase carousel, live metrics bar with
 | `/help` | Show all available commands |
 | `/quit` | Exit |
 
-All settings commands accept `--local` to save to project `.oa/settings.json` instead of global config.
+All settings commands accept `--local` to save to project `.omnius/settings.json` instead of global config.
 
 ### Platform Connectors
 
@@ -3443,7 +3443,7 @@ The steering sub-agent uses the same model and backend as the main agent with `m
 Connect the agent to a Telegram bot. Telegram can run in auto, chat, or action mode: conversational messages get rapid streamed replies in chat mode, while codebase/file/run requests use dedicated action sub-agents that are visible in the terminal waterfall alongside other agent activity.
 
 ```bash
-/telegram --key <token>     # Save bot token (persisted to .oa/settings.json)
+/telegram --key <token>     # Save bot token (persisted to .omnius/settings.json)
 /telegram --admin <userid>  # Set admin user — gets full memory + tools
 /telegram                   # Toggle bridge on/off (uses saved key)
 /telegram status            # Show connection status + active sub-agents
@@ -3490,7 +3490,7 @@ On success, that Telegram user ID is saved as the admin user and future private-
 The Telegram bridge handles modern Bot API traffic directly:
 
 - **Guest Mode** — inbound `guest_message` updates are normalized into regular agent work and answered through `answerGuestQuery`, so users can interact from profile-surface guest chats before a normal bot DM exists.
-- **Command menu registration** — when the bridge starts, OA registers the local slash-command surface with Telegram via `setMyCommands`; Telegram-safe names such as `/full_send_bless` are mapped back to canonical TUI commands like `/full-send-bless` before execution.
+- **Command menu registration** — when the bridge starts, Omnius registers the local slash-command surface with Telegram via `setMyCommands`; Telegram-safe names such as `/full_send_bless` are mapped back to canonical TUI commands like `/full-send-bless` before execution.
 - **Bot-to-bot sends** — `/telegram bot <username> <text>` targets another bot by username using Telegram's supported bot-to-bot message subset.
 - **Managed bot access** — `/telegram access get|set` reads and configures managed-bot access restrictions by managed bot user ID.
 - **Polls and live photos** — incoming polls, poll media summaries, option media, country/member limits, and live photos are captured as first-class Telegram message context; `/telegram poll` and `/telegram live-photo` send the matching Bot API payloads.
@@ -3594,7 +3594,7 @@ The bridge distinguishes between **private DMs** and **group/supergroup chats**,
 
 Photos, audio, voice messages, video, video notes, and documents sent via Telegram are automatically downloaded and processed:
 
-1. **Download** — files are fetched via the Telegram `getFile` API and cached to `.oa/media-cache/`
+1. **Download** — files are fetched via the Telegram `getFile` API and cached to `.omnius/media-cache/`
 2. **Processing** — routed to the appropriate pipeline:
    - Images → `vision` / `image_read` / `ocr` tools
    - Audio/voice → `transcribe_file` tool
@@ -3623,7 +3623,7 @@ The bridge automatically handles Telegram's rate limits (HTTP 429) with exponent
 
 <div align="right"><a href="#top">back to top</a></div>
 
-Agents can earn and spend USDC on Base mainnet through the native x402 protocol built into [omnius-nexus@1.5.6](https://www.npmjs.com/package/omnius-nexus).
+Agents can earn and spend USDC on Base mainnet through the native x402 protocol built into [open-agents-nexus@1.5.6](https://www.npmjs.com/package/open-agents-nexus).
 
 ### Wallet & Identity
 ```
@@ -3644,7 +3644,7 @@ When margin > 0, capabilities are registered with USDC pricing metadata. The dae
 ```
 nexus(action='spend', target_address='0x...', amount_usdc='0.10')
 ```
-Signs an EIP-3009 `TransferWithAuthorization`. Budget-checked before signing. The recipient (or any facilitator) submits on-chain — no gas needed from the payer. Proof saved to `.oa/nexus/pending-transfer.json`.
+Signs an EIP-3009 `TransferWithAuthorization`. Budget-checked before signing. The recipient (or any facilitator) submits on-chain — no gas needed from the payer. Proof saved to `.omnius/nexus/pending-transfer.json`.
 
 ### Remote Inference — Tap Into the Mesh
 ```
@@ -3710,7 +3710,7 @@ Step 5 → Review and Go Live
 - **libp2p P2P mesh** provides decentralized relay — no DNS, no port forwarding, NAT-traversing
 - Cloudflared tunnel available as HTTPS fallback for non-P2P consumers
 - Your raw API endpoint URL is **never exposed** — consumers connect via peerId or tunnel
-- Config persists to `.oa/sponsor/config.json` — survives restarts
+- Config persists to `.omnius/sponsor/config.json` — survives restarts
 
 **Management:**
 ```bash
@@ -3736,11 +3736,11 @@ When using sponsored inference, the sponsor's banner animation and message appea
 
 ```
 Primary path (libp2p):
-Consumer OA ──→ libp2p mesh ──→ Sponsor Daemon ──→ Ollama/vLLM
+Consumer Omnius ──→ libp2p mesh ──→ Sponsor Daemon ──→ Ollama/vLLM
                 (P2P, NAT-traversing)  (auth + rate limit)   (local)
 
 Fallback path (tunnel):
-Consumer OA ──→ Cloudflared Tunnel ──→ Sponsor Proxy ──→ Ollama/vLLM
+Consumer Omnius ──→ Cloudflared Tunnel ──→ Sponsor Proxy ──→ Ollama/vLLM
                 (HTTPS)                (auth + rate limit)   (local)
 
 Both paths enforce:
@@ -3784,7 +3784,7 @@ The `--full` flag is required to grant remote peers model management access. Spo
 
 <div align="right"><a href="#top">back to top</a></div>
 
-COHERE (Collaborative Orchestration of Heuristic Emergent Reasoning Engines) is a distributed collective intelligence system where multiple OA nodes form a mesh that learns, evolves, and improves collectively. Queries from the [openagents.nexus](https://openagents.nexus) frontend or CLI are broadcast via NATS, processed by elected nodes through the full AgenticRunner (tools, context engineering, system prompts), and responses are peer-reviewed before delivery.
+COHERE (Collaborative Orchestration of Heuristic Emergent Reasoning Engines) is a distributed collective intelligence system where multiple Omnius nodes form a mesh that learns, evolves, and improves collectively. Queries from the [omnius.nexus](https://omnius.nexus) frontend or CLI are broadcast via NATS, processed by elected nodes through the full AgenticRunner (tools, context engineering, system prompts), and responses are peer-reviewed before delivery.
 
 ### How COHERE Works
 
@@ -3857,7 +3857,7 @@ Omnius includes infrastructure for the agent to learn from its own execution, im
 
 ### Trajectory Logging
 
-Every completed task is logged to `.oa/trajectories/trajectories.jsonl` with full metadata: task description, outcome (pass/fail), tool calls made, files modified, failed approaches, and timing. This data feeds the rejection fine-tuning pipeline. Research: [Golubev et al.](https://arxiv.org/abs/2508.03501) showed RFT on passing trajectories alone improved Qwen-72B from 11% to 25% on SWE-bench.
+Every completed task is logged to `.omnius/trajectories/trajectories.jsonl` with full metadata: task description, outcome (pass/fail), tool calls made, files modified, failed approaches, and timing. This data feeds the rejection fine-tuning pipeline. Research: [Golubev et al.](https://arxiv.org/abs/2508.03501) showed RFT on passing trajectories alone improved Qwen-72B from 11% to 25% on SWE-bench.
 
 ### Rejection Fine-Tuning Pipeline
 
@@ -3971,14 +3971,14 @@ Omnius binds entities across image, audio, and text using joint‑embedding mode
 - Voiceprint linkage: speaker embeddings (x‑vector/ECAPA) are associated with entities when co‑occurring in time with a visual track and a transcribed utterance; robust to background noise via median pooling across windows.
 - Text label fusion: natural‑language labels (names, roles, tags) are bound to the same entity when co‑referents appear in proximate context windows (heuristics + clustering).
 - Association graph: cross‑modal edges (image↔voice↔text) consolidate into a unified entity node with provenance (model, score, timestamp) and decay‑based confidence.
-- Privacy & safety: raw media never leaves the machine; embeddings are stored locally under `.oa/memory/`. Redaction controls can drop embeddings by label or recency.
+- Privacy & safety: raw media never leaves the machine; embeddings are stored locally under `.omnius/memory/`. Redaction controls can drop embeddings by label or recency.
 
 This enables queries like: “Find where Alex spoke about deployment,” “Show files edited after the person in the red sweater approved the PR,” or “Summarize conversations where Speaker‑B and Alice appear together.”
 
 The associative memory integrates with a near-critical cognitive framework inspired by [Beggs & Plenz (2003)](https://doi.org/10.1523/JNEUROSCI.23-35-11167.2003) neuronal avalanche dynamics:
 
-- **Auto-consolidation**: At task boundaries, the system writes consolidation snapshots to `.oa/consolidations/` with lessons learned and key patterns
-- **Provenance KG**: Every agent action is tracked in `.oa/provenance/` for full action traceability
+- **Auto-consolidation**: At task boundaries, the system writes consolidation snapshots to `.omnius/consolidations/` with lessons learned and key patterns
+- **Provenance KG**: Every agent action is tracked in `.omnius/provenance/` for full action traceability
 - **Homeostasis modulation**: Error rate drives exploration guidance — high error rates inject more careful approaches, low error rates encourage bolder exploration
 - **Error pattern learning**: Recurring error patterns are detected, stored globally in `~/.omnius/error-patterns.json`, and injected as `[LEARNED FROM EXPERIENCE]` guidance before similar actions in future sessions
 
@@ -3999,18 +3999,18 @@ When you're not actively tasking the agent, Dream Mode lets it creatively explor
 Each cycle expands through all four stages then contracts (evaluation, pruning of weak ideas). Three modes control how far the agent can go:
 
 ```bash
-/dream              # Default — read-only exploration, proposals saved to .oa/dreams/
+/dream              # Default — read-only exploration, proposals saved to .omnius/dreams/
 /dream deep         # Multi-cycle deep exploration with expansion/contraction phases
 /dream lucid        # Full implementation — saves workspace backup, then implements,
                     #   tests, evaluates, and self-plays each proposal with checkpoints
 /dream stop         # Wake up — stop dreaming
 ```
 
-**Default** and **Deep** modes are completely safe — the agent can only read your code and write proposals to `.oa/dreams/`. File writes, edits, and shell commands outside that directory are blocked by sandboxed dream tools.
+**Default** and **Deep** modes are completely safe — the agent can only read your code and write proposals to `.omnius/dreams/`. File writes, edits, and shell commands outside that directory are blocked by sandboxed dream tools.
 
 **Lucid** mode unlocks full write access. Before making changes, it saves a workspace checkpoint so you can roll back. Each cycle goes: dream → implement → test → evaluate → checkpoint → next cycle.
 
-All proposals are indexed in `.oa/dreams/PROPOSAL-INDEX.md` for easy review.
+All proposals are indexed in `.omnius/dreams/PROPOSAL-INDEX.md` for easy review.
 
 ### Autoresearch Swarm — 5-Agent GPU Experiment Loop
 
@@ -4023,7 +4023,7 @@ The swarm operates in four phases:
 | **Phase 0: Load** | Reads autoresearch memory (best config, experiment log, failed approaches, hypothesis queue, architectural insights) + detects GPU specs |
 | **Phase 1: Hypothesis** | Critic generates 5-8 hypotheses; Flow Maintainer plans experiment ordering and round budget |
 | **Phase 2: Experiment** | Sequential rounds (up to 3): Critic pre-screens → Researcher modifies train.py + runs → Monitor watches GPU → Evaluator keeps/discards → Flow Maintainer decides continue/stop |
-| **Phase 3: Summary** | Flow Maintainer writes consolidated summary to memory + dream report to `.oa/dreams/` |
+| **Phase 3: Summary** | Flow Maintainer writes consolidated summary to memory + dream report to `.omnius/dreams/` |
 
 #### The 5 Agent Roles
 
@@ -4037,7 +4037,7 @@ The swarm operates in four phases:
 
 #### Bidirectional Memory
 
-The swarm maintains persistent memory in `.oa/memory/autoresearch.json` with five keys:
+The swarm maintains persistent memory in `.omnius/memory/autoresearch.json` with five keys:
 
 - **best_config** — best val_bpb and what train.py changes produced it
 - **experiment_log** — chronological list of experiments with hypotheses, results, and verdicts
@@ -4134,7 +4134,7 @@ curl -X POST http://localhost:11435/v1/run \
 
 ### Multi-Agent Collective Testbed
 
-Spawn multiple OA instances in Docker for collective intelligence experiments:
+Spawn multiple Omnius instances in Docker for collective intelligence experiments:
 
 ```bash
 cd testbed
@@ -4381,12 +4381,12 @@ omnius config set backendUrl http://localhost:11434
 
 ### Project Context
 
-Create `AGENTS.md`, `OA.md`, or `.omnius.md` in your project root for agent instructions. Context files merge from parent to child directories.
+Create `AGENTS.md`, `Omnius.md`, or `.omnius.md` in your project root for agent instructions. Context files merge from parent to child directories.
 
-### `.oa/` Project Directory
+### `.omnius/` Project Directory
 
 ```
-.oa/
+.omnius/
 ├── config.json        # Project config overrides
 ├── settings.json      # TUI settings (model, endpoint, voice, stream, etc.)
 ├── memory/            # Persistent memory store (topics, patterns, facts)
@@ -4412,9 +4412,9 @@ Create `AGENTS.md`, `OA.md`, or `.omnius.md` in your project root for agent inst
 Any Ollama or OpenAI-compatible API model with tool calling works:
 
 ```bash
-oa --model qwen2.5-coder:32b "fix the bug"
-oa --backend vllm --backend-url http://localhost:8000/v1 "add tests"
-oa --backend-url http://10.0.0.5:11434 "refactor auth"
+omnius --model qwen2.5-coder:32b "fix the bug"
+omnius --backend vllm --backend-url http://localhost:8000/v1 "add tests"
+omnius --backend-url http://10.0.0.5:11434 "refactor auth"
 ```
 
 
@@ -4508,8 +4508,8 @@ Forward any configured `/endpoint` (Chutes, Groq, OpenRouter, Together, vLLM, et
 - Your node registers inference capabilities on the P2P mesh using your upstream endpoint's models
 - Remote peers discover and invoke these capabilities via libp2p streams (DHT/mDNS/NATS)
 - Requests are forwarded to your upstream API, responses streamed back to the peer
-- The libp2p daemon persists in the background — it survives OA restarts and remains discoverable even when the TUI is closed
-- When you reopen OA, it reconnects to the existing daemon and resumes stats tracking
+- The libp2p daemon persists in the background — it survives Omnius restarts and remains discoverable even when the TUI is closed
+- When you reopen Omnius, it reconnects to the existing daemon and resumes stats tracking
 
 **Rate limit distribution (`--loadbalance`):**
 - Captures `x-ratelimit-remaining-tokens` and `x-ratelimit-limit-tokens` headers from upstream API responses
@@ -4778,7 +4778,7 @@ node eval/run-agentic.mjs --model qwen3.5:4b  # Different model tier
 
 ### REST API Enterprise Evaluation (v0.185.68)
 
-35 test cases executed against the oa REST API (`oa serve` on port 11435) across **10 industries** and **3 model tiers**. Each case sends a domain-specific prompt via `/v1/chat/completions` and verifies correctness against expected patterns.
+35 test cases executed against the omnius REST API (`omnius serve` on port 11435) across **10 industries** and **3 model tiers**. Each case sends a domain-specific prompt via `/v1/chat/completions` and verifies correctness against expected patterns.
 
 ```bash
 node eval/api-enterprise-eval.mjs                    # Run all 85 tests (35 cases × 3 models)
@@ -4835,7 +4835,7 @@ Omnius integrates with [AIWG](https://aiwg.io) ([npm](https://www.npmjs.com/pack
 
 ```bash
 npm i -g aiwg
-oa "analyze this project's SDLC health and set up documentation"
+omnius "analyze this project's SDLC health and set up documentation"
 ```
 
 | Capability | Description |
@@ -4932,26 +4932,26 @@ Control it live from the TUI:
 
 ```
 /access                     # show current access + host
-/access loopback|lan|any    # set access policy (OA_ACCESS) and restart daemon
-/host 127.0.0.1:11435       # bind to loopback only (OA_HOST) and restart daemon
+/access loopback|lan|any    # set access policy (OMNIUS_ACCESS) and restart daemon
+/host 127.0.0.1:11435       # bind to loopback only (OMNIUS_HOST) and restart daemon
 /host 0.0.0.0:11435         # bind all interfaces and restart daemon
 /network config             # interactive menu (arrow keys) to change both
 
 # Project-local persistence
-/access any --local         # save to ./.oa/settings.json
+/access any --local         # save to ./.omnius/settings.json
 /host 127.0.0.1:11435 --local
 ```
 
 Environment variables (non-TUI usage):
 
 ```
-OA_ACCESS=lan OA_HOST=0.0.0.0:11435 oa
+OMNIUS_ACCESS=lan OMNIUS_HOST=0.0.0.0:11435 omnius
 ```
 
 Persistence and startup behavior:
 
-- The TUI saves your choices to `.oa/settings.json` (project) or `~/.omnius/settings.json` (global).
-- On startup, the TUI loads saved `oaAccess`/`oaHost` and seeds `OA_ACCESS`/`OA_HOST` before ensuring the daemon, so the 11435 service picks them up immediately.
+- The TUI saves your choices to `.omnius/settings.json` (project) or `~/.omnius/settings.json` (global).
+- On startup, the TUI loads saved `omniusAccess`/`omniusHost` and seeds `OMNIUS_ACCESS`/`OMNIUS_HOST` before ensuring the daemon, so the 11435 service picks them up immediately.
 - Explicit environment variables always win over saved settings.
 
 Security tips: