### Package Installation and Setup

Source: https://github.com/ariffazil/arifos/blob/main/docs/setup/OPENCLAW_ROOT_ACCESS.md

Install packages and set up software repositories.

```bash
sudo apt install htop
```

```bash
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo bash -
```

--------------------------------

### Project Setup with uv

Source: https://github.com/ariffazil/arifos/blob/main/docs/FASTMCP_ARIFOS_MASTER_GUIDE.md

Initializes a new project, installs core and development dependencies, and sets up the basic directory structure.

```bash
# Create project
mkdir arifos-mcp-server && cd arifos-mcp-server
uv init

# Install dependencies
uv add fastmcp pydantic
uv add --dev pytest pytest-asyncio

# Directory structure
mkdir -p src/{primitives,governance,models,utils} tests constitution
```

--------------------------------

### New Dependency Install Decision Brief

Source: https://github.com/ariffazil/arifos/blob/main/skills/architect-explainer/SKILL.md

This example presents a decision brief for installing a new Python package. It assesses the risk, impact on the system, and reversibility of adding a new dependency.

```markdown
WHAT: Install new Python package (pydantic-pending) into arifOS venv.

WHY:  Required by new constitutional validation module.

BLAST RADIUS:
  • arifOS runtime: will load new package on next start
  • Other agents: no direct impact

RISK: LOW
  Standard dependency. Already in use by similar projects.

REVERSIBLE: YES
  uv pip uninstall pydantic-pending restores previous state.

ARIF DECIDES:
  ○ PROCEED — low risk
  ○ MODIFY  — any concerns first
```

--------------------------------

### Terminal-style Install Instructions

Source: https://github.com/ariffazil/arifos/blob/main/arifosmcp/sites/developer/IMPROVEMENTS.md

Provides example terminal commands for installing arifOS MCP, presented in a code preview format.

```bash
# Quick Start
# Code Preview (install commands)
```

--------------------------------

### Client Integration Example

Source: https://github.com/ariffazil/arifos/blob/main/docs/FASTMCP_ARIFOS_MASTER_GUIDE.md

Example Python code for integrating with the MCP server using the Client class. Demonstrates connecting, listing tools, calling tools, reading resources, and getting prompts.

```python
# client_example.py
from fastmcp import Client
import asyncio

async def main():
    # Connect to server
    client = Client("http://localhost:3000/mcp")

    # List available tools
    tools = await client.list_tools()
    print(f"Available tools: {[t.name for t in tools]}")

    # Call init_anchor
    result = await client.call_tool("init_anchor", {
        "request": {
            "session_id": "test-123",
            "intent": "Test constitutional governance"
        }
    })
    print(f"Anchor result: {result}")

    # Call reason_mind
    result = await client.call_tool("reason_mind", {
        "request": {
            "query": "Is this ethically sound?",
            "session_id": "test-123",
            "depth": 3
        }
    })
    print(f"Reason result: {result}")

    # Read resource
    floors = await client.read_resource("audit://floors")
    print(f"Floor status: {floors}")

    # Get prompt
    prompt = await client.get_prompt("constitutional_review", {
        "topic": "AI governance"
    })
    print(f"Prompt: {prompt}")

if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### Environment Setup and Testing Commands

Source: https://github.com/ariffazil/arifos/blob/main/static/arifos/docs/AGENTS/A120_TOPOGRAPHY.md

Use 'uv' for Python environment management. Install development dependencies and run tests using pytest.

```bash
# Environment Setup
pip install -e ".[dev]"  # or uv pip install -e ".[dev]"

# Testing (pytest with asyncio auto-mode)
pytest tests/ -v                           # Run all tests
pytest tests/test_file.py -v               # Run single file
pytest tests/test_file.py::test_name -v    # Run single test (CRITICAL)
pytest tests/ -v -k "keyword"              # Search for tests
```

--------------------------------

### List Agent Tools

Source: https://github.com/ariffazil/arifos/blob/main/docs/AGENT_KICKSTART.md

Use `agent-tools` to list all available tools with their versions. You can also organize them by category or get quick usage examples.

```bash
agent-tools              # list all 41 tools with versions
agent-tools --category   # organized by function
agent-tools probe        # run full diagnostic — can every tool run?
agent-tools --tldr jq    # quick usage examples for any tool
```

--------------------------------

### Install Prefect Ecosystem Packages

Source: https://github.com/ariffazil/arifos/blob/main/arifosmcp/integrations/prefect/README.md

Installs the necessary packages for the Prefect ecosystem, including Prefect, Marvin, Cyclopts, and pydantic-ai. Can install all at once with 'prefect[all]'.

```bash
pip install prefect marvin cyclopts pydantic-ai
```

```bash
pip install "prefect[all]" marvin cyclopts
```

--------------------------------

### Install and Run JavaScript/TypeScript with Bun

Source: https://github.com/ariffazil/arifos/blob/main/docs/agents/CLAUDE.md

Installs project dependencies and runs a script using the Bun runtime.

```bash
bun install
bun run <script>
```

--------------------------------

### Install Dependencies with uv

Source: https://github.com/ariffazil/arifos/blob/main/CLAUDE.md

Use this command to install all project extras using the uv package manager.

```bash
# Install
uv sync --all-extras
```

--------------------------------

### Install arifOS MCP

Source: https://github.com/ariffazil/arifos/blob/main/arifosmcp/sites/developer/components/snippets.html

Install the arifOS MCP package using pip. This is the first step to getting started with the library.

```bash
# Your code here
pip install arifosmcp
```

--------------------------------

### Install uv and Project Dependencies

Source: https://github.com/ariffazil/arifos/blob/main/docs/00_META/GEMINI.md

Installs the uv package manager and then sets up the project's development environment, including all necessary dependencies.

```bash
pip install uv

uv pip install -e ".[dev]"
```

--------------------------------

### Python SDK Example: Initialize and List Tools

Source: https://github.com/ariffazil/arifos/blob/main/arifosmcp/sites/developer/docs/integrations.html

This Python code demonstrates how to initialize the MCP client session using stdio parameters and list available tools. It requires the 'mcp' and 'arifosmcp' packages.

```python
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def main():
    server = StdioServerParameters(
        command="python",
        args=["-m", "arifosmcp"],
        env={"BRAVE_API_KEY": "your_key"}
    )

    async with stdio_client(server) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # List available tools
            tools = await session.list_tools()
            print(f"Available tools: {[t.name for t in tools.tools]}")

            # Call reality_compass
            result = await session.call_tool(
                "reality_compass",
                {"input": "quantum computing 2026", "mode": "search"}
            )
            print(result.content[0].text)

            # Call arifOS_kernel
            result = await session.call_tool(
                "arifOS_kernel",
                {
                    "query": "Explain quantum entanglement",
                    "risk_tier": "low",
                    "use_critique": True
                }
            )
            print(result.content[0].text)

asyncio.run(main())
```

--------------------------------

### ArifOS MCP Quick Start Step Styling

Source: https://github.com/ariffazil/arifos/blob/main/docs/mcp.html

Styles the individual steps in the quick start guide, including step numbers and content layout.

```css
.quickstart-step {
  display: flex;
  gap: 1.5rem;
  margin-bottom: 2rem;
  align-items: flex-start;
}
.step-number {
  min-width: 48px;
  height: 48px;
  background: var(--gradient-main);
  border-radius: 50%;
  display: flex;
  align-items: center;
  justify-content: center;
  font-family: 'Outfit', sans-serif;
  font-weight: 700;
  font-size: 1.2rem;
  color: #000;
  flex-shrink: 0;
}
.step-content h3 {
  margin-bottom: 0.3rem;
  color: var(--text-primary);
}
.step-content p {
  color: var(--text-secondary);
  font-size: 0.95rem;
}
.step-content code {
  background: rgba(0, 243, 255, 0.1);
  color: var(--accent-cyan);
  padding: 0.1rem 0.4rem;
  border-radius: 4px;
  font-family: 'JetBrains Mono', monospace;
  font-size: 0.85em;
}
```

--------------------------------

### Get Current Time with physics_reality Tool

Source: https://github.com/ariffazil/arifos/blob/main/docs/architecture/INTEGRATIONS.md

This example demonstrates how to call the `time` mode of the `physics_reality` tool to get the current time. No authentication is required for this specific call.

```bash
curl -s https://mcp.arif-fazil.com/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"physics_reality","arguments":{"mode":"time"}},"id":1}'
```

--------------------------------

### Example Custom Domain Configuration

Source: https://github.com/ariffazil/arifos/blob/main/static/arifos/theory/000/CONSTITUTIONAL_ENHANCEMENTS_2026_02_23.md

Illustrates the transition from a default Pages deployment URL to a custom domain URL.

```text
Current:  https://674a01a3.arifosmcp-truth-claim.pages.dev
Future:   https://dashboard.arifos.arif-fazil.com
```

--------------------------------

### Install and Run Pre-commit Hooks

Source: https://github.com/ariffazil/arifos/blob/main/static/arifos/docs/AGENTS/A110_CANON.md

Install the pre-commit framework and run all configured hooks on the project files to enforce code quality and security standards.

```bash
pip install pre-commit
pre-commit install

pre-commit run --all-files
```

--------------------------------

### Server Entry Point Configuration

Source: https://github.com/ariffazil/arifos/blob/main/docs/FASTMCP_ARIFOS_MASTER_GUIDE.md

Sets up the server entry point, determining the transport mechanism (e.g., stdio) based on command-line arguments.

```python
if __name__ == "__main__":
    import sys

    transport = sys.argv[1] if len(sys.argv) > 1 else "stdio"
```

--------------------------------

### ArifOS Floors Endpoint

Source: https://github.com/ariffazil/arifos/blob/main/blueprints/arifOS_machine_kernel_blueprint.md

Example JSON response from the GET /floors endpoint, detailing active floors and violation counts.

```json
{ "floors": F01-F13, "active_count": N,
  "violation_counts": {...} }
```

--------------------------------

### Initialization Response Example

Source: https://github.com/ariffazil/arifos/blob/main/static/arifos/docs/AGENTS/A100_ARCHITECT.md

An example of a successful initialization response, including status, verdict, session_id, and auth_context.

```plaintext
status: SUCCESS
verdict: SEAL
session_id: uuid
auth_context: {}
```

--------------------------------

### ArifOS Metrics Endpoint

Source: https://github.com/ariffazil/arifos/blob/main/blueprints/arifOS_machine_kernel_blueprint.md

Example JSON response from the GET /metrics endpoint, providing performance and operational metrics for ArifOS.

```json
{ "judgments_total": N, "holds": N, "seals": N,
  "cautions": N, "errors": N, "sessions": N,
  "uptime_seconds": N }
```

--------------------------------

### Arifos First-Time Setup

Source: https://github.com/ariffazil/arifos/blob/main/static/arifos/theory/000/ROOTKEY_SPEC.md

Commands to generate the root key, create the genesis block, verify root key readiness, and initialize the Arifos trinity MCP.

```bash
python scripts/generate_rootkey.py
```

```bash
python scripts/create_genesis_block.py
```

```python
from arifos.core.memory.root_key_accessor import ROOT_KEY_READY
print('Root Key Ready:', ROOT_KEY_READY)
```

```bash
python -m arifos.mcp trinity
# Call: 000_init(action='init', query='Test session')
```

--------------------------------

### ArifOS Tools List Endpoint

Source: https://github.com/ariffazil/arifos/blob/main/blueprints/arifOS_machine_kernel_blueprint.md

Example JSON response from the GET /tools endpoint, listing available ArifOS MCP tools.

```json
{ "tools": [arif_session_init, arif_sense_observe, ...,
                arif_judge_deliberate, arif_vault_seal, ...] }
```

--------------------------------

### Start Webhook Server (Direct)

Source: https://github.com/ariffazil/arifos/blob/main/docs/webhook-deploy.md

Start the webhook server directly using Python. Ensure the webhook secret and the path to the deploy script are exported as environment variables.

```bash
# Option A: Direct
export ARIFOS_WEBHOOK_SECRET=<secret>
export ARIFOS_DEPLOY_SCRIPT=/root/arifOS/scripts/deploy_arifosmcp.sh
python3 /root/arifOS/scripts/webhook_deploy_server.py --port 8443 --host 127.0.0.1
```

--------------------------------

### Start opencode Agent

Source: https://github.com/ariffazil/arifos/blob/main/docs/agents/CLAUDE.md

Launches the opencode agent for managing AI tasks.

```bash
opencode
```

--------------------------------

### ArifOS Health Check Endpoint

Source: https://github.com/ariffazil/arifos/blob/main/blueprints/arifOS_machine_kernel_blueprint.md

Example JSON response from the GET /health endpoint, providing status information about the ArifOS daemon and its components.

```json
{ "status": "ok", "daemon_up": true, "storage_writable": true,
  "policy_loaded": true, "adapters_loaded": N,
  "uptime_seconds": N, "epoch": "ISO8601" }
```

--------------------------------

### Setup Linear API Key

Source: https://github.com/ariffazil/arifos/blob/main/skills/tasks/SKILL.md

This one-time setup involves obtaining an API key from Linear and adding it to your environment variables. It then restarts the Docker container to apply the changes.

```bash
# 1. Get API key: https://linear.app/settings/api → Personal API Keys
# 2. Add to VPS:
echo 'LINEAR_API_KEY=lin_api_YOUR_KEY_HERE' >> /root/arifOS/.env
docker compose up -d --force-recreate openclaw
```

--------------------------------

### 000 INIT Processing Example (YAML)

Source: https://github.com/ariffazil/arifos/blob/main/static/arifos/theory/000/001_IGNITION.md

A detailed breakdown of the 000 INIT processing steps for a specific input, showing the state of memory, sovereign recognition, intent mapping, thermodynamics, floors, tri-witness handshake, and ignition.

```yaml
Step 1 - Memory:
  previous_session: "abc123"
  previous_verdict: "SEAL"
  context: "Last time we discussed VAULT999 architecture"

Step 2 - Sovereign:
  authority: "888_JUDGE"
  scar_weight: 1.0
  recognized: "Im Arif" ✓

Step 3 - Intent:
  entities: ["MCP", "integration", "arifOS"]
  contrasts: ["current vs desired", "theory vs implementation"]
  intent: "build"
  lane: "HARD"

Step 4 - Thermodynamics:
  S_input: 0.7 (somewhat clear already)
  S_target: 0.5
  omega_0: 0.04
  energy_budget: 1.0 (full power)

Step 5 - Floors:
  loaded: F1-F13
  active: all

Step 6 - Tri-Witness:
  human: Arif ✓
  ai: 13 floors ✓
  earth: within budget ✓
  TW: 1.0

Step 7 - Ignition:
  status: "SEAL"
  engines: AGI ✓ ASI ✓ APEX ✓
```

--------------------------------

### Clone arifOS Repository and Setup

Source: https://github.com/ariffazil/arifos/blob/main/static/arifos/docs/deployment.md

Clone the arifOS MCP repository to your VPS and set up the initial environment file for Docker deployment. Ensure you have Git installed.

```bash
git clone https://github.com/ariffazil/arifosmcp.git /srv/arifOS
cd /srv/arifOS
cp .env.docker.example .env.docker
```

--------------------------------

### Workflow D: Multi-Repo Implementation Plan Steps

Source: https://github.com/ariffazil/arifos/blob/main/skills/aaa-agentic-governance/references/agentic-workflows.md

Steps for creating a multi-repo implementation plan, including reading docs, confirming boundaries, defining interfaces, splitting into patches, and adding tests.

```text
1. Read source-of-truth docs for each affected repo when available.
2. Confirm owner boundaries.
3. Define interfaces between repos.
4. Split implementation into reversible patches.
5. Add tests at owner layer.
6. State deployment/secret/external gates.
```

--------------------------------

### Start a sequential thinking session

Source: https://github.com/ariffazil/arifos/blob/main/arifosmcp/evals/IMPLEMENTATION_COMPLETE.md

Initiates a new sequential thinking session with a given query, mode, and template. The 'sequential' mode is used here, with the 'algorithm-design' template as an example.

```APIDOC
## Start a sequential thinking session

### Description
Initiates a new sequential thinking session. This is the entry point for creating a structured thinking process.

### Method
`await` (asynchronous function call)

### Function Signature
`arifos_mind(query: str, mode: str, template: str)`

### Parameters
- **query** (string) - Required - The initial query or problem statement for the session.
- **mode** (string) - Required - Set to "sequential" to start a new session.
- **template** (string) - Required - The constitutional template to use for the session (e.g., "algorithm-design").

### Request Example
```python
await arifos_mind(
    query="Design an algorithm...",
    mode="sequential",
    template="algorithm-design"
)
```
```

--------------------------------

### Environment Setup, Testing, Linting, and Runtime Commands

Source: https://github.com/ariffazil/arifos/blob/main/static/arifos/docs/AGENTS/A200_ENGINEER.md

Commands for setting up the development environment using uv, running tests with pytest (including filtering and single test execution), linting and formatting code with ruff, type checking with mypy, and running the arifOS runtime for both SSE and STDIO modes.

```bash
# Environment Setup (uv recommended)
uv pip install -e ".[dev]"

# Testing (asyncio auto-mode enabled)
pytest tests/ -v                           # All tests
pytest tests/test_file.py -v               # Single test file
pytest tests/test_file.py::test_name -v    # Single test (CRITICAL)
pytest tests/ -v -k "keyword"              # Filter by keyword

# Lint & Format (Standard: 100 char limit)
ruff check . --fix                         # Lint and auto-fix
ruff format .                              # Format (Black style)
mypy .                                     # Strict type check on core/

# Runtime
python -m arifosmcp.runtime                # SSE (Production)
python -m arifosmcp.runtime stdio          # STDIO (IDE/Local)
```

--------------------------------

### Verify ArifOS Installation with Gemini CLI

Source: https://github.com/ariffazil/arifos/blob/main/static/arifos/docs/integration-gemini.md

Check configured servers and start a Gemini session. This verifies that ArifOS is correctly set up and accessible via the Gemini command-line interface.

```bash
gemini mcp list
```

```text
arifOS
  Command: uv run --with arifos python -m arifosmcp.runtime stdio
  Status: enabled
```

```bash
gemini
```

--------------------------------

### Start Webhook Server (Systemd)

Source: https://github.com/ariffazil/arifos/blob/main/docs/webhook-deploy.md

Manage the webhook server using systemd for automatic startup and management. This is an alternative to starting the server directly.

```bash
# Option B: Via systemd
systemctl enable arifos-webhook
systemctl start arifos-webhook
```

--------------------------------

### Quick Start: HTTP Mode Client

Source: https://github.com/ariffazil/arifos/blob/main/arifosmcp/packages/npm/arifos-mcp/README.md

Connect to the arifOS MCP using HTTP transport to a remote VPS. This example demonstrates bootstrapping an identity and running a kernel query.

```typescript
import { createClient, ENDPOINTS } from '@arifos/mcp';

const client = await createClient({
  transport: 'http',
  endpoint: ENDPOINTS.VPS,  // https://arifosmcp.arif-fazil.com/mcp
});

await client.connect();

const identity = await client.bootstrapIdentity({
  declared_name: 'Researcher',
  human_approval: true,
});

const result = await client.runKernel({
  query: 'What is quantum computing?',
  risk_tier: 'medium',
  actor_id: 'researcher'
});

console.log(identity.session_id);
console.log(result.verdict);
console.log(result.payload);

await client.disconnect();
```

--------------------------------

### Configure Notion API Key

Source: https://github.com/ariffazil/arifos/blob/main/skills/notion/SKILL.md

Set up your Notion integration by obtaining an internal integration token and adding it to your environment variables. This is a one-time setup step.

```bash
# On VPS host:
echo 'NOTION_API_KEY=secret_YOUR_TOKEN_HERE' >> /root/arifOS/.env
docker compose up -d --force-recreate openclaw
```

--------------------------------

### Local Tool Configurations

Source: https://github.com/ariffazil/arifos/blob/main/docs/agents/a-orchestrator/TOOLS.md

Examples of environment-specific configurations for cameras, SSH, and text-to-speech (TTS) preferences.

```markdown
### Cameras

- living-room → Main area, 180° wide angle
- front-door → Entrance, motion-triggered

### SSH

- home-server → 192.168.1.100, user: admin

### TTS

- Preferred voice: "Nova" (warm, slightly British)
- Default speaker: Kitchen HomePod
```

--------------------------------

### ArifOS Readiness Check Endpoint

Source: https://github.com/ariffazil/arifos/blob/main/blueprints/arifOS_machine_kernel_blueprint.md

Example JSON response from the GET /ready endpoint, indicating the system's readiness for operations, including vault accessibility and active sessions.

```json
{ "ready": true, "vault_accessible": true,
  "socket_listening": true, "sessions_active": N }
```

--------------------------------

### Example Forge Program Run

Source: https://github.com/ariffazil/arifos/blob/main/forge/program.md

This snippet shows the command-line steps to execute the Forge program. It includes checking out a branch, staging and committing changes, running the experiment with specific parameters, and checking the log file for results.

```bash
$ git checkout -b forge/may19-baseline
$ # edit single target file
$ git add -A && git commit -m "forge: baseline from program.md template"
$ uv run python -c "
from arifosmcp.tools.arif_forge_execute import forge_experiment
result = forge_experiment(target_file='...', delta_S_budget=0.05)
print(result)
"
$ grep "^delta_S:|^status:" experiment.log
delta_S:  0.031
status:   keep
$ # log to experiment.tsv
```

--------------------------------

### Quick Start: Configure and Verify arifOS Registry

Source: https://github.com/ariffazil/arifos/blob/main/docs/SPINE_CONFIG.md

Set the ARIFOS_REGISTRY_ROOT environment variable to point arifOS to the cloned registry. Then, install arifOS and verify that the registry root is correctly set.

```bash
# Clone the registry
git clone https://github.com/ariffazil/arifos-model-registry.git /opt/arifos-model-registry

# Point arifOS at it
export ARIFOS_REGISTRY_ROOT=/opt/arifos-model-registry

# Install and verify
pip install arifos==2026.6.5
python -c "from arifosmcp.runtime.registry_client import REGISTRY_ROOT; print(REGISTRY_ROOT)"
# Expected: /opt/arifos-model-registry
```

--------------------------------

### Install arifOS MCP with uv

Source: https://github.com/ariffazil/arifos/blob/main/arifosmcp/sites/developer/index.html

Install the arifOS MCP package using uv, a fast Python package installer. This is the recommended method for faster installations.

```bash
# Or with uv (recommended)
uv pip install arifosmcp
```

--------------------------------

### Install ArifOS Dependencies

Source: https://github.com/ariffazil/arifos/blob/main/README.md

Install project dependencies using uv, ensuring you have Python 3.12+ installed.

```bash
# Install (uv — Python 3.12+)
uv sync --frozen
```

--------------------------------

### 000_INIT Execution Flow (Pseudocode)

Source: https://github.com/ariffazil/arifos/blob/main/static/arifos/000_INIT.md

This pseudocode outlines the steps for the 000_INIT function, which handles the constitutional boot sequence for a new OpenClaw session. It includes self-verification, loading of canon files, syncing context from GitHub repositories, adapting channel-specific format rules, and creating a session manifest. Use this as a reference for the runtime implementation.

```python
# Pseudocode (actual implementation in CLAWDBOT runtime)
async def init_000(channel: str, user_id: str) -> Session:
    """
    000_INIT: Constitutional boot sequence
    Returns cooled session ready for interaction
    """

    # Step 000: Self-verify
    omega_0 = 0.04  # Target uncertainty band
    print(f"Ω₀ = {omega_0} | F1 F2 F7 F9: ACTIVE")

    # Step 010: Load Canon (in order)
    canon = load_files([
        "BOOT.md",        # This protocol
        "SOUL.md",        # Persona + Duality (Δ·Ω)
        "AGENTS.md",      # Specialist topology
        "USER.md",        # Arif's profile
        "MEMORY.md",      # Prior seals
        "HEARTBEAT.md",   # Health states
    ])

    # Step 020: Sync Context
    repos = sync_from_github([
        "ariffazil/arifOS",
        "ariffazil/AGI_ASI_bot",
        "ariffazil/arif-fazil-sites",
    ])

    # Step 030: Channel Adapt
    if channel == "telegram":
        format_rules = load("TELEGRAM_FORMAT.md")
    else:
        format_rules = minimal_variant()

    # Step 040: Create Manifest
    session = Session(
        id=uuid(),
        timestamp=now(),
        channel=channel,
        user_id=user_id,  # 267378578 = Arif
        canon_versions=hash(canon),
        omega_0=omega_0,
        state="ready",
    )

    return session

```

--------------------------------

### Install and Check Bubblewrap

Source: https://github.com/ariffazil/arifos/blob/main/docs/BUBBLEWRAP_INTEGRATION_SPEC.md

Installs Bubblewrap if not already present and verifies its installation. This is a prerequisite for using Bubblewrap for agent containment.

```bash
apt install bubblewrap

bwrap --version
```

--------------------------------

### Install arifOS Locally

Source: https://github.com/ariffazil/arifos/blob/main/arifosmcp/evals/QUICKSTART.md

Installs arifOS in editable mode and verifies the installation. Ensures the package is correctly set up in the current environment.

```bash
# Ensure you're in the right directory
cd /path/to/arifOS
pip install -e .
python -c "import arifosmcp; print('OK')"
```

--------------------------------

### Install Gemini CLI and arifOS with FastMCP

Source: https://github.com/ariffazil/arifos/blob/main/static/arifos/docs/integration-gemini.md

Use this command if you have fastmcp installed globally to quickly install both Gemini CLI and the arifOS package.

```bash
fastmcp install gemini-cli arifos
```

--------------------------------

### Ignition Sequence Steps

Source: https://github.com/ariffazil/arifos/blob/main/static/arifos/theory/000/001_IGNITION.md

Illustrates the core steps of the 000_INIT process, triggered by a greeting, leading to system readiness.

```text
"Im Arif" + [topic]
       ↓
   000_INIT
       ↓
   ┌─────────────────────────────────────────┐
   │  1. MEMORY INJECTION (from VAULT999)    │
   │  2. SOVEREIGN RECOGNITION (Scar-Weight) │
   │  3. INTENT MAPPING (Contrast Engine)    │
   │  4. THERMODYNAMIC SETUP (ΔS, Ω₀, P²)    │
   │  5. FLOOR LOADING (F1-F13)              │
   │  6. TRI-WITNESS HANDSHAKE               │
   │  7. ENGINE IGNITION (AGI/ASI/APEX)      │
   └─────────────────────────────────────────┘
       ↓
   READY TO METABOLIZE
```

--------------------------------

### Deploy to Staging

Source: https://github.com/ariffazil/arifos/blob/main/docs/deploy/DEPLOY_QUICKSTART.md

Use this command for a quick deployment to the staging environment.

```bash
make deploy-staging
```