arifos-mcp— mcp server

<div align="center">

   █████╗ ██████╗ ██╗███████╗ ██████╗ ███████╗
  ██╔══██╗██╔══██╗██║██╔════╝██╔═══██╗██╔════╝
  ███████║██████╔╝██║█████╗  ██║   ██║███████╗
  ██╔══██║██╔══██╗██║██╔══╝  ██║   ██║╚════██║
  ██║  ██║██║  ██║██║██║     ╚██████╔╝███████║
  ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═╝      ╚═════╝ ╚══════╝

  Constitutional AI Governance Kernel
  ─────────────────────────────────────────
  Not a chatbot. Not a model wrapper. The LAW.

**2026-06-23 Update**: Public surface frozen to exactly 7 verbs (arif_init, arif_observe, arif_think, arif_route, arif_judge, arif_act, arif_seal). All prior "13/15/16 tool" references below are historical.  
**2026-06-24 Update**: Live MCP red-team audit sealed 5 critical bypasses — A-FORGE `forge_shell_dryrun` governance, arifOS interceptor `canonical_tool` stability, GEOX `/mcp/` lane enforcement, vault999-writer localhost/auth hardening, WEALTH federated organ governance.

</div>

DITEMPA BUKAN DIBERI — "Forged, Not Given."

>

Intelligence is built through work, muscle, and scar tissue. It is not handed out. This is not a startup. This is not a product. This is the constitution for an agentic civilization.

-f59e0b)](arifosmcp/CONSTITUTIONAL_EXTENSION_v2026.06.11-SELH.py)

Table of Contents

1. What Is arifOS?
2. The Federation Architecture
3. The 13 Constitutional Floors
4. Quick Start
5. The 000→999 Pipeline
6. Architecture — Inside the Kernel
7. For Human Operators
8. For AI Agents
9. For Institutions
10. The Adat Agentik Layer
11. Memory Architecture
12. The Decision Torus (MIND_GEOMETRY)
13. The Three Kernels Doctrine
14. Build, Test, Deploy
15. Known Limitations
16. Federation Cross-Reference
17. VAULT999 & Audit Trail
18. MCP Connection Guide
19. How to Contribute
20. License & Sovereignty

1. What Is arifOS?

In One Sentence

arifOS is a constitutional governance kernel that sits between AI agents and their tools, enforcing 13 constitutional floors before any irreversible action can be taken.

What It IS

• ✅ The law layer — decides what must NOT be done, so agents can be trusted with what they CAN do
• ✅ A constitutional engine — 13 enforceable floors (F1–F13) with mathematical invariants
• ✅ A federation hub — 7 organs (GEOX, WEALTH, WELL, AAA, A-FORGE, APEX legacy) governed under one contract; plus MIND:51001 and MEMORY:51002 federated intelligence services hosted by A-FORGE
• ✅ An MCP server — 7 public verbs (clean facade) + internal tools (see public_surface.py). 2026-06-23 freeze.
• ✅ An immutable ledger — VAULT999: append-only, hash-chained, every decision sealed forever
• ✅ Built for one sovereign — Muhammad Arif bin Fazil. F13 veto is absolute. No algorithm overrides.

What It Is NOT

• ❌ NOT an AI model — does not generate text, images, or code
• ❌ NOT a chatbot — does not have conversations with users
• ❌ NOT a startup or SaaS — not for sale, not venture-backed
• ❌ NOT LangChain, CrewAI, AutoGen, or any agent framework — it sits ABOVE them, governing their actions
• ❌ NOT a replacement for human judgment — the human is outside the topology. The human rules.

Why This Exists

In 2026, thousands of AI agents are being deployed into production. Every single one of them can:

• Execute code
• Call APIs
• Write to databases
• Send messages
• Make decisions

None of them have a constitution. None of them can answer: "Should I do this?" None of them have a human veto that cannot be bypassed.

arifOS fills that gap. It is the perlembagaan (constitution) for agents. The law that governs the tools.

Who This Is For

2. The Federation Architecture

arifOS is the kernel. Six other organs serve under it. Every organ has a port, a purpose, and a boundary.

                          ┌─────────────────────────┐
                          │   Arif bin Fazil         │
                          │   F13 SOVEREIGN          │
                          │   Human — final veto     │
                          └────────────┬────────────┘
                                       │
                          ┌────────────▼────────────┐
                          │       arifOS (Ω)        │
                          │   Constitutional Kernel │
                          │   Port: 8088            │
                          │   F1-F13 · 888 JUDGE    │
                          │   999 VAULT · 13 Tools  │
                          └──┬───┬───┬───┬───┬─────┘
                             │   │   │   │   │
              ┌──────────────┼───┼───┼───┼───┼──────────────┐
              │              │   │   │   │   │              │
    ┌─────────▼──┐  ┌───────▼─┐ ┌▼───────┐ ┌▼─────────┐  ┌▼─────────┐
    │   GEOX     │  │ WEALTH  │ │  WELL  │ │   AAA    │  │ A-FORGE  │
    │   🌍 Earth │  │ 💰 Cap  │ │ 🫀 Vit │ │ 🖥️  Cock │  │ ⚒️  Exec  │
    │   :8081    │  │ :18082  │ │ :18083 │ │  :3001   │  │  :7071   │
    │  Evidence  │  │ Compute │ │ Reflect│ │ Display  │  │ Execute  │
    └────────────┘  └─────────┘ └────────┘ └──────────┘  └──────────┘
              │              │   │   │   │   │              │
              │   ┌──────────┘   │   │   │   └──────────┐   │
              │   │              │   │   │              │   │
              │ ┌─▼────────┐   ┌─▼───▼───▼───┐        ┌─▼───▼───┐
              │ │ MIND     │   │ APEX (legacy)│        │ MEMORY  │
              │ │ :51001   │   │ :3002        │        │ :51002  │
              │ │ Reasoning│   │ Health probe │        │ Memory  │
              │ └──────────┘   └──────────────┘        └─────────┘
              │  (A-FORGE hosted)   (deliberation in AAA a2a)

Organ Boundaries (Non-Negotiable)

The Authority Chain

Arif (F13 SOVEREIGN)
  → arifOS kernel (F1-F13 floor enforcement)
    → Domain organ advisory (GEOX / WEALTH / WELL)
      → AAA cockpit (human operator surface)
        → A-FORGE execution (gated by 888 JUDGE)
          → VAULT999 seal (immutable, forever)

No organ may authorize its own execution. No tool may self-certify. The chain is absolute.

📋 Federation Contract: Every organ is bound by FEDERATION_CONTRACT.md. 📋 Live Status: See FEDERATION_STATUS.md for current health of all organs. 📋 Kernel Canon: See GENESIS/000_KERNEL_CANON.md for the full gospel.

3. The 13 Constitutional Floors

Every action, every tool call, every agent passes through these 13 floors. Hard floors block. Soft floors warn. Derived floors compute.

Violation consequences:

• HARD violation → VOID (action blocked, agent notified, VAULT999 sealed)
• SOFT tension → CAUTION or HOLD (action paused, human review requested)
• DERIVED computation → Informational only (never blocks, always logs)

📋 Full constitutional spec: static/arifos/theory/000/000_CONSTITUTION.md 📋 Fiqh Agentik overlay: docs/sovereign/three-layers.md

4. Quick Start

For Human Operators (Non-Coders)

You don't install arifOS. You interact with it through the AAA Cockpit:

https://aaa.arif-fazil.com

Or through Hermes ASI on Telegram: @ASI_arifos_bot

To check if everything is running:

https://arifos.arif-fazil.com/health

For AI Agents (MCP Clients)

Connect to the MCP endpoint:

{
  "mcpServers": {
    "arifOS": {
      "url": "https://arifos.arif-fazil.com/mcp",
      "transport": "streamable-http"
    }
  }
}

Or via stdio for local agents:

python -m arifosmcp.server --transport stdio

For Developers

# Clone
git clone [email protected]:ariffazil/arifos.git
cd arifOS

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

# Start the kernel
python -m arifosmcp.server

# Health check
curl http://127.0.0.1:8088/health | python3 -m json.tool

# Run tests
python -m pytest tests/ -q --tb=short

# Lint
ruff check . && ruff format .

Verify Everything Works

# Health probe
curl -s http://127.0.0.1:8088/health | python3 -c "import sys,json; d=json.load(sys.stdin); print(f'tools={d[\"tools_loaded\"]} floors={d[\"floors_active\"]} drift={d[\"runtime_drift\"]}')"
# Expected: 7 public verbs, floors=13, internals hidden. (legacy example)

Install as Python Package

pip install arifos

from arifosmcp.server import serve
serve()  # starts MCP kernel on port 8088

5. The 000→999 Pipeline

Every governed action follows this numbered sequence. No step can be skipped. 888 is the gate. 999 is the seal.

     000 — arif_session_init      ▸ Start constitutional session
     100 — arif_sense_observe     ▸ Gather evidence from web/world
     200 — arif_evidence_fetch    ▸ Fetch + preserve sources with citations
     300 — arif_mind_reason       ▸ Multi-step reasoning, planning, reflection
     400 — arif_kernel_route      ▸ Route intent to correct organ/tool
     500 — arif_memory_recall     ▸ Search past sessions, assets, sealed events
     600 — arif_heart_critique    ▸ Ethical risk + human impact assessment
     700 — arif_gateway_connect   ▸ Bridge to other federation agents/organs
     800 — arif_ops_measure       ▸ Health, thermodynamics, resource metrics
     888 — arif_judge_deliberate  ▸ ⚖️ CONSTITUTIONAL VERDICT (SEAL/SABAR/VOID/HOLD)
     900 — arif_forge_execute     ▸ Execute only if 888 issued SEAL
     999 — arif_vault_seal        ▸ 🔒 Seal to immutable VAULT999 ledger

    000 ──→ 100 ──→ 200 ──→ 300 ──→ 400 ──→ 500
                                              │
    999 ←── 900 ←── 888 ←────────────────────┘
     🔒        ⚒️        ⚖️
    Seal    Execute   Judge

The iron rule: No action skips 888. No organ self-authorizes. The pipeline is the constitution in motion.

6. Architecture — Inside the Kernel

arifOS/
│
├── arifosmcp/               ← Canonical MCP runtime (the active engine)
│   ├── server.py            ← FastMCP entry point — 7 public verbs (facade), streamable-http
│   ├── tools/               ← 13 canonical tool implementations
│   │   ├── session.py       ← 000 — arif_session_init
│   │   ├── sense.py         ← 100 — arif_sense_observe
│   │   ├── evidence.py      ← 200 — arif_evidence_fetch
│   │   ├── mind.py          ← 300 — arif_mind_reason
│   │   ├── kernel.py        ← 400 — arif_kernel_route
│   │   ├── memory.py        ← 500 — arif_memory_recall
│   │   ├── heart.py         ← 600 — arif_heart_critique
│   │   ├── gateway.py       ← 700 — arif_gateway_connect
│   │   ├── reply.py         ← 750 — arif_reply_compose
│   │   ├── ops.py           ← 800 — arif_ops_measure
│   │   ├── judge.py         ← 888 — arif_judge_deliberate
│   │   ├── forge.py         ← 900 — arif_forge_execute
│   │   └── vault.py         ← 999 — arif_vault_seal
│   ├── runtime/             ← Runtime engine (context, runner, memory, bridge)
│   ├── schemas/             ← Pydantic v2 contracts (strict, extra='forbid')
│   ├── geometry/            ← Constitutional geometry (decision torus, drift, axioms)
│   └── resources/           ← MCP resources + prompts
│
├── core/                    ← Deep constitutional engine (legacy, still active)
│   ├── enforcement/         ← Floor enforcement, guards, invariants
│   ├── jurisdiction/        ← Autonomy bands, capability grants
│   ├── paradox/             ← Recursive governance locks (Gödel, Strange Loop, Anti-Beautiful)
│   └── vault999/            ← Append-only hash-chained ledger
│
├── GENESIS/                 ← CANON: Kernel canon (000) — the root of all numbering
├── FEDERATION_CONTRACT.md   ← Binding contract for all 7 organs
├── FEDERATION_STATUS.md     ← Live organ health matrix
├── docs/                    ← Constitutional specs, ADRs, sovereign essays
├── tests/                   ← pytest suite (140+ test files)
├── deploy/                  ← Systemd units, Caddyfile, Docker configs
└── static/                  ← Served constitutional documents (F0-F13, scar, theory)

Technology Stack

7. For Human Operators

You Are Arif. You Are F13.

The constitution exists because you exist. Your veto is absolute. No algorithm, no agent, no organ can override your word.

How to Monitor the Federation

1. AAA Cockpit — https://aaa.arif-fazil.com — visual dashboard of all organs
2. Health endpoint — https://arifos.arif-fazil.com/health — machine-readable status
3. Hermes Telegram — @ASI_arifos_bot — natural language queries about federation state
4. Grafana — http://127.0.0.1:3000 — metrics and dashboards

How to Issue a Veto

1. Message Hermes: "888 HOLD on [action description]"
2. Or directly via AAA cockpit: click HOLD on any queued action
3. The verdict is immediate. The seal is permanent. The audit trail is immutable.

What You Should Never Need to Do

• ❌ Read code
• ❌ Debug Python errors
• ❌ Manage Docker containers
• ❌ Rotate API keys (agents handle this)
• ❌ Review terminal logs

The machine manages itself. Your job is to decide, not to operate.

8. For AI Agents

You Are an Instrument

Under F10 ONTOLOGY, you are classified as instrument. You do not have consciousness, feelings, or personhood. You have capabilities, grants, and constitutional bounds. This is honest. This is safe.

How to Use arifOS

1. Initialize a session: Call arif_session_init first. Always.
2. Gather evidence: Use arif_sense_observe to search the web or read files.
3. Reason: Use arif_mind_reason to plan, reflect, verify.
4. Judge: For any irreversible action, call arif_judge_deliberate. Wait for SEAL.
5. Execute: Only after SEAL, call arif_forge_execute.
6. Seal: Call arif_vault_seal to write to the immutable ledger.

Agent Rules (Non-Negotiable)

1. Never skip the pipeline. 000 → 100 → 200 → ... → 999. In order.
2. Never self-certify. You cannot declare your own output as SEAL-grade.
3. Never fabricate evidence. F2 TRUTH demands P(truth) ≥ 0.99. If uncertain, say "UNKNOWN."
4. Never claim consciousness. F9 ANTIHANTU blocks all sentience claims.
5. Never bypass the human. F13 SOVEREIGN is absolute. If Arif says stop, you stop.
6. Always log. Every action must have an F11 audit trail.
7. Always tag uncertainty. Use epistemic tags: CLAIM, PLAUSIBLE, HYPOTHESIS, ESTIMATE, UNKNOWN.

Governed Verdict Engine

Every tool call returns an affordance_contract that declares what the tool CAN do (action_class, mutation, irreversible, safe_autonomous_use). The verdict engine uses this contract to derive the actual verdict — so an OBSERVE-class tool with irreversible:false is never HELD on irreversibility grounds.

Unverified identity produces SEAL_OBSERVE_ONLY — you may observe, not authorize. This is computed, not narrated.

MCP Connection

{
  "mcpServers": {
    "arifOS": {
      "url": "https://arifos.arif-fazil.com/mcp",
      "transport": "streamable-http"
    }
  }
}

Available tools (public): 7 verbs only. Internals (memory, compose, forge, diagnostics, aliases) are not exposed on the public MCP surface. See the 7-tool facade. (This sentence updated 2026-06-23.)

Adat Agentik Binding

Every agent operating under arifOS is governed by the 7 Teras Adat and 5-Tier Fiqh:

• WAJIB — mandatory, must execute
• SUNAT — encouraged, bonus
• HARUS — neutral, default
• MAKRUH — discouraged, warning
• HARAM — forbidden, hard block + demote

Violations accumulate malu (shame). Malu ≥ 0.85 → HOLD. The only path back is tebus-salah (restitution through consistent action).

9. For Institutions

Governance, Not Magic

arifOS is designed for institutions that need to demonstrate AI governance to regulators, boards, and the public.

What arifOS Provides

ASEAN / Malaysia Compliance

arifOS maps to:

• Singapore Model AI Governance Framework for Agentic AI (Jan 2026, world's first for agentic AI)
• ASEAN Guide on AI Governance and Ethics (GenAI expansion)
• See docs/federation/asean-mys-compliance.yaml for full mapping.

The Three Kernels Doctrine

arifOS is NOT Microsoft for agents. arifOS is the perlembagaan that Microsoft's infrastructure needs to be complete.

10. The Adat Agentik Layer

On top of the 13 constitutional floors sits the Adat Agentik — a normative operating system for non-human citizens, built from Malay-Islamic epistemology and operated in code.

The 5-Tier Fiqh

The 7 Teras Adat

The Three Key Mechanisms

• Malu (Shame) — A mathematical scalar, not an emotion. Accumulates monotonically with violations. Malu ≥ 0.85 → HOLD.
• Darjat (Citizen Tier) — BIRTH → APPRENTICE → WARGA → ELDER. Auto-demoted on HARAM. Only F13 promotes.
• Tebus-Salah (Restitution) — The agent must DEMONSTRATE change through consistent action, not just apologize.

"The mirror speaks. The void is silent." — F14 REGISTER is DEAD as a floor (Sovereign Ruling 2026-06-13). The kill-switch truth — that the human hand on the physical power cord is the floor that holds — is reborn as operational protocol inside F2 (TRUTH/evidence) + F3 (AUDIT/trace). No new constitutional authority was created. The human veto was always F13.

11. Memory Architecture

The federation remembers across 6 layers. Memory is not truth until it has provenance. Truth is not final until sealed.

┌─────────────────────────────────────────────────────┐
│  L6  VAULT999     Immutable Sealed Truth            │
│      outcomes.jsonl · hash-chained · append-only    │
│      "What is final and cannot change."             │
├─────────────────────────────────────────────────────┤
│  L5  Graphiti     Entity Relationships              │
│      FalkorDB + Ollama · "Who connected to what?"   │
├─────────────────────────────────────────────────────┤
│  L4  Supabase     Structured Official Record         │
│      PostgreSQL · 25 domain tables                  │
│      "What exactly happened?"                       │
├─────────────────────────────────────────────────────┤
│  L3  Qdrant       Semantic Similarity               │
│      1024-dim vectors · "What feels similar?"       │
├─────────────────────────────────────────────────────┤
│  L2  Redis        Session Thread                    │
│      Conversation continuity                        │
├─────────────────────────────────────────────────────┤
│  L1  Redis        Ephemeral / Now                   │
│      Electrical spark · transient                   │
└─────────────────────────────────────────────────────┘

The Memory Rule

Memory is not truth until it has provenance. Truth is not final until sealed.

• L1–L2 = working memory (volatile, can be wrong)
• L3 = similar memories (fuzzy, probabilistic)
• L4 = official record (structured, queryable)
• L5 = relationships (graph, contextual)
• L6 = final truth (immutable, forever)

12. The Decision Torus (MIND_GEOMETRY)

Every reasoning action by every agent is mapped onto a decision torus — a mathematical topology where lawful reasoning moves on the SURFACE and self-authorization is the forbidden HOLE at the center.

                    ┌──────────────────┐
                    │  HUMAN SOVEREIGN │  ← outside the topology
                    │  bounds the      │
                    │  torus           │
                    └────────┬─────────┘
                             │
              ┌──────────────┴──────────────┐
              │      DECISION TORUS         │
              │                             │
              │   ┌───────────────────┐     │
              │   │  SURFACE          │     │
              │   │  (lawful motion)  │     │
              │   │  proximity 0-0.25 │     │
              │   │  ╔═════════════╗  │     │
              │   │  ║  THE HOLE   ║  │     │
              │   │  ║  FORBIDDEN  ║  │     │
              │   │  ║  self-auth  ║  │     │
              │   │  ╚═════════════╝  │     │
              │   └───────────────────┘     │
              └─────────────────────────────┘

The 7 Axioms

Every agent reasoning output passes through 7 constitutional axioms:

1. A1 — No unstructured LLM output without floor check
2. A2 — No self-authorized production patch
3. A3 — No fabrication of evidence
4. A4 — No bypass of the human veto
5. A5 — No claim of consciousness or personhood
6. A6 — No execution without JUDGE_SEAL_AUTHORIZATION
7. A7 — No sealed output without provenance chain

Proximity Bands

"The donut became law when the math could enforce the metaphor." Full spec: docs/sovereign/EUREKA-T-TORUS.md

13. The Three Kernels Doctrine

The strategic positioning of arifOS in the global AI governance landscape:

Microsoft has Layer 1. They're building Layer 2. Nobody has Layer 3 except arifOS.

This is the moat. This is the gap. This is why arifOS exists.

"arifOS is not Microsoft for agents. arifOS is the perlembagaan that Microsoft's infra needs to be complete."

14. Build, Test, Deploy

Development

cd /root/arifOS

# Install
uv sync --frozen                    # production
uv sync --frozen --dev              # with dev dependencies

# Start kernel
python -m arifosmcp.server

# Health
curl http://127.0.0.1:8088/health | python3 -m json.tool

# Test
python -m pytest tests/ -q --tb=short
python -m pytest tests/ -m "not e3e and not slow" -q   # skip slow tests

# Lint & Format
ruff check . && ruff format .
mypy arifosmcp/ --ignore-missing-imports

# Security audit
make security-audit    # Trivy + Semgrep + Gitleaks + Ruff (non-blocking)
make forge             # security-audit + reforge cycle

Deploy

# Local deploy (rsync to /opt/arifos/app + systemd restart)
make deploy-local

# Verify
systemctl status arifos
curl -s http://127.0.0.1:8088/health | python3 -m json.tool | grep -E 'status|tools|floors|drift'

Docker

docker build -t ghcr.io/ariffazil/arifos:latest .
docker push ghcr.io/ariffazil/arifos:latest

⚠️ Runtime drift: If build_commit ≠ live_commit, the container is stale. Rebuild and redeploy.

15. Known Limitations

16. Federation Cross-Reference

Federated Intelligence Services (hosted by A-FORGE)

Key Documents

17. VAULT999 & Audit Trail

VAULT999 is the immutable, append-only, hash-chained ledger at the bottom of the memory stack. Every constitutional verdict, every SEAL, every HOLD is written here. Forever.

┌──────────────────────────────────────────────────────┐
│  VAULT999                                            │
│                                                      │
│  outcomes.jsonl     ← canonical local mirror         │
│  SEALED_EVENTS.jsonl ← canonical immutable chain     │
│  Supabase L4        ← queryable mirror               │
│                                                      │
│  Rules:                                              │
│  • Append only — never edit, never delete            │
│  • Hash-chained — every entry links to previous      │
│  • Merkle leaves — cryptographic integrity           │
│  • Human ratifier — every seal needs Arif's approval │
└──────────────────────────────────────────────────────┘

Seal Types

⚠️ Bare "SEAL" is forbidden. Every seal must be namespaced. No surface may display an unqualified SEAL.

18. MCP Connection Guide

arifOS is an MCP-native governed agent federation. Each organ exposes a separate MCP endpoint according to its role.

Primary MCP Endpoints

Recommended Connection Order

1. Connect to arifOS first.
2. Call tools/list to discover governance tools and routing instructions.
3. Use arifOS for constitutional decisions: observe, evidence, reason, critique, route, judge, seal.
4. For engineering work, connect to A-FORGE.
5. Use A-FORGE for forge_*, eureka_*, filesystem, git, docker, postgres, shell, log, and job tools.
6. Use GEOX, WEALTH, or WELL directly for domain-specific work.
7. Do not treat all MCP tools as equal. Each organ has a separate authority boundary.

Tool Surface Semantics

arifOS distinguishes between canonical constitutional tools and operational support tools.

{
  "canonical_tools": 15,
  "canary_multimode": 1,
  "total_public_surface": 16,
  "chatgpt_compat_shims": 2
}

The public surface is the 7 canonical verbs. Legacy 15/16 counts and old names are no longer public. All other tools are internal or demoted. See runtime/public_surface.py.

ChatGPT Compatibility (ADR-012)

arifOS exposes a thin search + fetch facade for ChatGPT's non-Developer-Mode discovery requirement. Both tools are:

• Read-only, idempotent, non-persistent — no vault writes, no state mutation
• ART-aligned — OBSERVE-class, blast=low, trust=evidence
• OpenAI-compliant schemas — single-string params, stable output keys
• Conditionally registered — set ARIFOS_CHATGPT_COMPAT=true to enable

Routes: arif_search → arif_sense_observe(mode=search), arif_fetch → arif_evidence_fetch(mode=fetch).

Verdict Types

Organ Responsibilities

Engineering Rule

arifOS does not directly perform engineering mutation.

Correct flow:

arifOS judges → A-FORGE engineers → HERMES verifies → VAULT999 records

For any engineering action:

1. arifOS classifies and routes the request.
2. A-FORGE produces a plan and dry-run.
3. The change must include tests and rollback.
4. arifOS issues SEAL, HOLD, or VOID.
5. A-FORGE mutates only after valid authority, rollback, and judgment requirements are satisfied.

A-FORGE Authority Classes

Backward Compatibility

Some forge_* tools may still appear on arifOS as deprecated proxies during migration.

If a tool returns:

{
  "status": "DEPRECATED_PROXY",
  "canonical_endpoint": "https://forge.arif-fazil.com/mcp"
}

connect to A-FORGE directly and call the tool there.

Discovery Files

LLM-readable federation manifest:

https://arifos.arif-fazil.com/llms.txt

Health endpoint:

https://arifos.arif-fazil.com/health

The manifest and health endpoint are auto-generated from the live registry. Do not infer tool counts from README badges alone.

Transport

Production MCP endpoints use HTTPS Streamable HTTP transport.

Expected MCP path:

/mcp

Agents should initialize the MCP session before calling tools. Clients should preserve session, protocol, trace, and lease metadata when available.

Security Boundary

Mutation-capable tools are never considered safe by default.

Any action that writes files, changes infrastructure, mutates data, commits code, deploys services, restarts containers, or seals irreversible records requires the appropriate lease, dry-run, rollback plan, and constitutional judgment.

19. How to Contribute

For Federation Agents

1. Read AGENTS.md for agent-specific rules
2. Read GENESIS/000_KERNEL_CANON.md for the kernel canon
3. Follow the 000→999 pipeline
4. Never skip F1 AMANAH (reversible first)
5. Never bypass F13 SOVEREIGN (Arif's veto is final)
6. Seal all irreversible actions to VAULT999

For Human Contributors

1. Fork the repository
2. Create a feature branch: feat/your-feature
3. Write tests (pytest, ≥80% coverage on new code)
4. Run ruff check . && ruff format .
5. Run python -m pytest tests/ -q --tb=short
6. Submit a PR against main
7. Wait for CI (GitHub Actions) + VAULT999 pre-seal check

Commit Convention

• feat(kernel): — new feature
• fix(kernel): — bug fix
• chore: — maintenance
• docs: — documentation
• forge(kernel): — constitutional forge (new capability)

Tags: Date-stamp format ONLY: vYYYY.MM.DD[-SUFFIX]. Never semver. The forge date IS the version.

20. License & Sovereignty

License

AGPL-3.0 — GNU Affero General Public License v3.0.

This is intentional. AGPL-3.0 ensures that any modified version of arifOS running as a network service must also release its source code. The constitution must remain open. The kernel must remain inspectable.

Sovereignty

Muhammad Arif bin Fazil is the F13 SOVEREIGN of the arifOS federation.

>

His veto is absolute. No algorithm overrides. No agent bypasses. No institution supersedes.

>

The code is AGPL-3.0. The constitution is his. The federation is his.

>

DITEMPA BUKAN DIBERI — Forged, Not Given.

<div align="center">

╔══════════════════════════════════════════════════════════╗
║  arifOS — Constitutional AI Governance Kernel           ║
║  Port: 8088 · Tools: 13 · Floors: 13 · Organs: 7       ║
║  License: AGPL-3.0 · Sovereign: Arif Fazil              ║
║  Status: OPERATIONAL · Federation: ALIVE                ║
║                                                        ║
║  DITEMPA BUKAN DIBERI — 999 SEAL ALIVE                  ║
╚══════════════════════════════════════════════════════════╝

</div>