Metadata-Version: 2.4
Name: adaad
Version: 10.20.0
Summary: ADAAD — Autonomous Development & Adaptation Architecture: governance-first constitutional AI evolution runtime
Author-email: InnovativeAI LLC <dev@innovativeai.io>
License: Proprietary
Project-URL: Homepage, https://github.com/InnovativeAI-adaad/ADAAD
Project-URL: Repository, https://github.com/InnovativeAI-adaad/ADAAD.git
Project-URL: Changelog, https://github.com/InnovativeAI-adaad/ADAAD/blob/main/CHANGELOG.md
Project-URL: Bug Tracker, https://github.com/InnovativeAI-adaad/ADAAD/issues
Keywords: autonomous-ai,constitutional-ai,governance,self-evolution,lineage-ledger,multi-agent,fastapi,ai-safety
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: License :: Other/Proprietary License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
Classifier: Typing :: Typed
Requires-Python: >=3.11
Description-Content-Type: text/markdown
License-File: LICENSE
License-File: LICENSES.md
License-File: NOTICE
Requires-Dist: fastapi>=0.135.2
Requires-Dist: uvicorn>=0.41.0
Requires-Dist: anthropic>=0.84.0
Requires-Dist: libcst<2.0,>=1.1.0
Requires-Dist: PyYAML>=6.0.3
Requires-Dist: PyNaCl>=1.6.2
Provides-Extra: dev
Requires-Dist: pytest>=8.0; extra == "dev"
Requires-Dist: httpx>=0.27.0; extra == "dev"
Requires-Dist: cryptography>=44.0.3; extra == "dev"
Requires-Dist: pytest-benchmark>=5.1.0; extra == "dev"
Requires-Dist: qrcode>=8.2; extra == "dev"
Provides-Extra: server
Requires-Dist: fastapi>=0.135.2; extra == "server"
Requires-Dist: uvicorn[standard]>=0.41.0; extra == "server"
Requires-Dist: sse-starlette>=2.0.0; extra == "server"
Dynamic: license-file

<div align="center">

<!-- ADAAD_VERSION_HERO:START -->
![ADAAD Hero Banner](docs/assets/readme/inline-hero_banner.svg)
<!-- ADAAD_VERSION_HERO:END -->

<br/>

<a href="#what-it-does">⚡ What it does</a>&nbsp;&nbsp;·&nbsp;&nbsp;<a href="#quickstart">🚀 Quickstart</a>&nbsp;&nbsp;·&nbsp;&nbsp;<a href="#capabilities">🧠 Capabilities</a>&nbsp;&nbsp;·&nbsp;&nbsp;<a href="docs/CONSTITUTION.md">📜 Constitution</a>&nbsp;&nbsp;·&nbsp;&nbsp;<a href="ROADMAP.md">🗺 Roadmap</a>&nbsp;&nbsp;·&nbsp;&nbsp;<a href="docs/thesis/ADAAD_THESIS.md">📖 Thesis</a>&nbsp;&nbsp;·&nbsp;&nbsp;<a href="DORK.md">🕵️ DORK</a>&nbsp;&nbsp;·&nbsp;&nbsp;<a href="TRUST_CENTER.md">🏛 Trust Center</a>&nbsp;&nbsp;·&nbsp;&nbsp;<a href="docs/VERIFIABLE_CLAIMS.md">✅ Verifiable Claims</a>

<br/>

[![Proprietary](https://img.shields.io/badge/license-Proprietary-ff4466?style=flat-square&labelColor=0d1117)](LICENSE)&nbsp;[![Python 3.12](https://img.shields.io/badge/python-3.12-00ff88?style=flat-square&labelColor=0d1117)](https://python.org)&nbsp;[![v10.20.0](https://img.shields.io/badge/version-v10.20.0-a855f7?style=flat-square&labelColor=0d1117)](CHANGELOG.md)&nbsp;[![713 Invariants](https://img.shields.io/badge/invariants-713%20Hard--class-ff4466?style=flat-square&labelColor=0d1117)](docs/governance/V8_CONSTITUTIONAL_INVARIANTS_MATRIX.md)&nbsp;[![114 Innovations](https://img.shields.io/badge/innovations-114%20shipped-f97316?style=flat-square&labelColor=0d1117)](ROADMAP.md)&nbsp;[![Free Download](https://img.shields.io/github/v/release/InnovativeAI-adaad/ADAAD?label=APK&color=00d4ff)](https://github.com/InnovativeAI-adaad/ADAAD/releases)&nbsp;[![GitHub commit activity](https://img.shields.io/github/commit-activity/m/InnovativeAI-adaad/adaad?style=flat-square&labelColor=0d1117&color=00d4ff&label=Commits%2Fmonth)](https://github.com/InnovativeAI-adaad/adaad/commits/main)

</div>

![Section Divider](docs/assets/readme/inline-divider.svg)

<div align="center">

## ADAAD is a self-evolving software system with a built-in governance layer.

Every proposed change goes through a 16-step pipeline. Every decision is recorded in a hash-chained ledger. Critical changes require a human key. None of this is configurable away.

</div>

![Section Divider](docs/assets/readme/inline-divider.svg)

<!-- ADAAD_VERSION_INFOBOX:START -->
> Auto-generated by scripts/version_sync.py
> Sync context note: release metadata is mirrored from governance/report_version.json.

| Field | Value |
| --- | --- |
| **Current version** | `10.20.0` |
| **Phase** | `209` |
| **Released** | `2026-06-05` |
| **Release SHA** | `85f785e` |
| **Hard-class invariants** | `713` |
| **Innovations shipped** | `114` |
<!-- ADAAD_VERSION_INFOBOX:END -->

![System Stats](docs/assets/readme/inline-stats_card.svg)

Canonical architecture spec: [`docs/governance/ARCHITECT_SPEC_v3.1.0.md`](docs/governance/ARCHITECT_SPEC_v3.1.0.md).

![Section Divider](docs/assets/readme/inline-divider.svg)

## <a id="what-it-does"></a>What ADAAD is

ADAAD proposes mutations to its own codebase, scores them against a cryptographically enforced constitution, red-teams them adversarially, executes them in a sandbox, verifies fitness, and delivers results to the governing human for ratification — all in a closed, auditable loop.

It is not an agent framework, not an LLM wrapper, and not a developer tool. It is a self-evolution engine with a governance layer that is structural, not advisory, and where every decision leaves a hash-chained record.

![Section Divider](docs/assets/readme/inline-divider.svg)

## What problem it solves

| Challenge | ADAAD's approach |
|:----------|:----------------|
| AI-proposed changes are hard to audit | Every decision is recorded in a hash-chained ledger that can be replayed from any point |
| Governance can be configured away | The governance gate is a structural primitive — there is no bypass flag or override |
| Human oversight is advisory in most systems | HUMAN-0 is a non-delegatable key that structurally gates critical changes |
| Self-improvement creates drift | Every mutation is scored, sandboxed, and sealed before promotion; regressions are caught at the verifier |

![Section Divider](docs/assets/readme/inline-divider.svg)

## <a id="capabilities"></a>What ADAAD can do

### Govern its own mutations
ADAAD scores every proposed change across five constitutional fitness axes — lineage depth, blast containment, velocity alignment, convergence delta, and constitutional debt — before a single line executes. Proposals that violate invariants are rejected fail-closed: a typed exception is raised, the operation terminates, and a ledger entry is written. There is no silent failure path.

### Red-team itself adversarially
Before any mutation reaches production, the Adversarial Fitness Red Team (AFRT) agent attempts to break it. The AFRT is structurally prohibited from approving its own challenges. A 2-of-3 constitutional jury then deliberates. The verdict is ledger-sealed.

### Execute mutations in a live shadow sandbox
The Live Shadow Mutation Execution engine runs proposed mutations against live traffic in a shadow context before promotion. Blast radius is modelled and bounded. Partial execution raises `MEX-ATOMIC-0` — there is no partially-applied mutation state.

### Verify its own fitness after execution
After execution, the Mutation Fitness Verifier grades the result as `CERTIFIED` or `REGRESSED`. The verdict is hash-chained. Regressed mutations do not promote.

### Score the constitutional impact of every innovation
The Innovation Impact Scorer computes per-invariant delta scoring for every shipped innovation. Every invariant in the system has a measurable fitness signal. The signal is ledger-recorded.

### Propose constitutional amendments and deliver them to a human
When the Constitutional Adaptive Learner identifies that an invariant's weighting should change based on observed fitness patterns, it generates a typed amendment recommendation. The Recommendation Delivery Protocol formats it as a governance proposal, queues it, and delivers it to HUMAN-0 for disposition — ACCEPTED, DEFERRED, or REJECTED. Every disposition is sealed in an immutable HMAC-chained ledger.

### Feed HUMAN-0 decisions back as selection pressure
When a HUMAN-0 disposition lands, the CEL Feedback Integrator translates it directly into MSE selection-weight adjustments. Accepted amendments amplify the corresponding fitness axis. Rejected ones decay it. The loop closes: human judgment becomes constitutional calibration signal, automatically.

### Reconstruct any past state deterministically
Every ledger entry is hash-chained. Every decision is replayable:
```bash
python -m app.main --replay strict --verbose
```

### Verify ledger integrity on demand
```bash
make audit
```
Full HMAC forward-walk of all active ledgers. Any tamper produces a named exception with byte-level location.

### Answer questions about its own governance history
DORK (Developer Operator Runtime Kernel) is a natural language interface to the entire constitutional history of the system. Ask why a mutation was blocked six weeks ago. Ask which invariants are under the most pressure. Ask it to reconstruct the full decision trail for any shipped capability. It answers with citations from the ledger — not from training data.

### Run on a $200 phone
The full governed runtime runs on Android via Termux. See [`TERMUX_SETUP.md`](TERMUX_SETUP.md).

### Assess its own GA readiness autonomously (INNOV-92 · GPE)
The **GA Promotion Engine** monitors every V10 convergence criterion in real-time and delivers a structured `HUMAN0_REQUIRED` signal the moment all criteria are met — triggering the GA tag ceremony without polling, drift, or manual state inspection.

```bash
# Assess current GA readiness
curl -X POST http://localhost:8000/api/gpe/assess \
  -H "Content-Type: application/json" \
  -d '{"pypi_version": "9.120.0"}'
# → {"verdict": "HUMAN0_REQUIRED", "criteria_met": 7, "criteria_total": 7}
```

All seven V10 convergence criteria are now satisfied. The V10.0.0 GA tag ceremony is the imminent next milestone — HUMAN-0 ratification only.

### Connect via GitHub App (ADAADchat)
**ADAADchat** is the governance-native GitHub App for ADAAD — HMAC-SHA256 verified webhooks, slash command dispatch, and a live governance bridge between GitHub events and the CEL.

```
# Slash commands (issue / PR comments)
/adaad status      → governance orientation report, open PRs, active phase
/adaad dry-run     → evaluate mutations through GovernanceGate, nothing applied
/adaad preflight   → boot invariants + agent contracts only
DEVADAAD           → full build + merge authority — all 5 gate tiers must pass
```

Install: [github.com/apps/adaadchat](https://github.com/apps/adaadchat)

![Section Divider](docs/assets/readme/inline-divider.svg)

## The closed self-improvement loop

```
┌─────────────────────────────────────────────────────────────────────┐
│              CEL SELF-IMPROVEMENT LOOP — FULLY CLOSED               │
│                                                                       │
│  MSE · Mutation Selection Engine                                      │
│    Scores candidates across 5 constitutional fitness axes             │
│        │                                                              │
│        ▼                                                              │
│  MRP · Mutation Risk Profiler  →  MPG · Phylogeny Graph              │
│    Pre-execution risk assessment and lineage mapping                  │
│        │                                                              │
│        ▼                                                              │
│  MEX · Mutation Execution Engine                                      │
│    Sandboxed execution, blast radius bounded, atomic                  │
│        │                                                              │
│        ▼                                                              │
│  MFV · Mutation Fitness Verifier                                      │
│    CERTIFIED or REGRESSED — no intermediate state                     │
│        │                                                              │
│        ▼                                                              │
│  IIS · Innovation Impact Scorer                                       │
│    Per-invariant delta scoring across the full constitution           │
│        │                                                              │
│        ▼                                                              │
│  CAL · Constitutional Adaptive Learner                                │
│    Identifies invariants whose weighting should change                │
│        │                                                              │
│        ▼                                                              │
│  RDP · Recommendation Delivery Protocol                               │
│    Formats and queues proposals for HUMAN-0 disposition               │
│        │                                                              │
│        ▼                                                              │
│  HUMAN-0 Disposition: ACCEPTED · DEFERRED · REJECTED                 │
│        │                                                              │
│        ▼                                                              │
│  CFI · CEL Feedback Integrator  ─────────────────────────┐           │
│    Translates disposition outcomes into MSE weight         │           │
│    adjustments — ACCEPTED amplifies, REJECTED decays       │           │
│        └───────────────────────────────────────────────────┘           │
│                        feeds back to MSE                              │
└─────────────────────────────────────────────────────────────────────┘
```

Every node enforces Hard-class invariants. Every node is fail-closed. Every node writes to an HMAC-chained ledger. The full loop is replayable from any point.

![Section Divider](docs/assets/readme/inline-divider.svg)

## The Constitutional Evolution Loop

Every mutation — without exception — traverses 16 steps before it ships:

<details>
<summary><strong>Expand: 16-step CEL</strong></summary>

```
┌─────────────────────────────────────────────────────────────────────────┐
│              CONSTITUTIONAL EVOLUTION LOOP (CEL) — 16 STEPS             │
│                      Every mutation. No exceptions.                      │
└─────────────────────────────────────────────────────────────────────────┘

  [1]  SPIE proposes innovation        [9]  Live Shadow Mutation Execution
  [2]  Morphogenetic memory consult    [10] Blast radius modelling
  [3]  Dream agent ideation            [11] Constitutional jury verdict (2-of-3)
  [4]  Architect structural review     [12] GovernanceGate final arbiter
  [5]  Beast performance scoring       [13] HUMAN-0 gate (Tier-0 changes only)
  [6]  AFRT adversarial red-team       [14] GPG-signed ledger entry
  [7]  Fitness surface evaluation      [15] Hash-chained CEPD proof
  [8]  Constitutional scoring          [16] Annotated tag + release evidence
       (547 Hard-class invariants)
```

Every step is deterministic. Every step produces a ledger record. Every ledger record is hash-chained. The entire pipeline is replayable from any point.

</details>

![Section Divider](docs/assets/readme/inline-divider.svg)

## The three agents

```
┌──────────────┬───────────────────────────────────────┬─────────────────────────┐
│    Agent     │              Role                     │      Disposition        │
├──────────────┼───────────────────────────────────────┼─────────────────────────┤
│  Architect   │  Governance, structure, invariant      │  Conservative. Blocks   │
│  (blue)      │  scoring against all 547 Hard-class    │  anything that breaks   │
│              │  invariants before any execution       │  constitutional integrity│
├──────────────┼───────────────────────────────────────┼─────────────────────────┤
│  Dream       │  Creativity, ideation, novelty         │  Bold. Proposes novelty.│
│  (violet)    │  Explores the mutation possibility     │  Checked by every other │
│              │  space inside constitutional guardrails│  layer before it ships  │
├──────────────┼───────────────────────────────────────┼─────────────────────────┤
│  Beast       │  Performance, resource fitness         │  Relentless. Maximises  │
│  (orange)    │  Benchmark scoring, hardware-adaptive  │  fitness within          │
│              │  evaluation and optimisation           │  constitutional bounds  │
└──────────────┴───────────────────────────────────────┴─────────────────────────┘
```

No agent can approve its own proposals. The AFRT is constitutionally prohibited from approving challenges it authored — invariant `AFRT-0`.

![Section Divider](docs/assets/readme/inline-divider.svg)

## DORK — Governance Intelligence Layer

**DORK** is the institutional memory of ADAAD — a natural language interface to the entire constitutional history of the system.

```
┌────────────────────────────────────────────────────────────────┐
│                    DORK Intelligence Stack                      │
├────────────────────────────────────────────────────────────────┤
│  DQR · Query Router                                            │
│    Every query → logged RouteDecision → priority dispatch      │
│    DPM score ≥ 0.35 → DPM  |  RAGS score ≥ 0.25 → RAGS      │
│    All others → passthrough  |  HUMAN-0 override gate         │
├───────────────────────┬────────────────────────────────────────┤
│  DPM · Persistent     │  RAGS · Grounded Response             │
│  Memory               │    Constitutional corpus retrieval     │
│  Session-agnostic     │    Cosine-scored citation chains       │
│  HMAC-chained         │    Zero-grounding gate (RAGS-GATE-0)  │
│  confidence-gated     │    Hash-chained grounding ledger       │
└───────────────────────┴────────────────────────────────────────┘
```

Ask DORK why a mutation was blocked six weeks ago. Ask which invariants are under the most pressure. Ask it to reconstruct the full decision trail for any shipped capability. It answers with citations drawn from the ledger — not from training data.

**Interface:** `ui/dork.html` — [aponi.adaad.pro](https://aponi.adaad.pro) or locally via `python server.py`  
**Streaming endpoint:** `POST /api/dork/stream`

See [DORK.md](DORK.md) for full documentation.

![Section Divider](docs/assets/readme/inline-divider.svg)

## Security guarantees

Structural guarantees — not policies, not configuration. Constitutionally enforced, cryptographically evidenced.

| Guarantee | Invariant | What it prevents |
|:----------|:----------|:-----------------|
| No mutation bypasses governance | `GOV-SOLE-0` | GovernanceGate bypass |
| No agent approves its own proposal | `AFRT-0` | Adversarial self-approval |
| No constitutional change without HUMAN-0 | `COMMUNITY-HUMAN0-0` | Autonomous self-amendment |
| No mutation reduces observability | `SELF-AWARE-0` | Blind spots in the governed loop |
| No unpinned Docker images in production | `DAS-DOCKER-0` | Supply chain drift |
| No innovation auto-approved without ratification | `SPIE-HUMAN0-0` | Unapproved capability injection |
| No persistent memory disabled at runtime | `DPM-GATE-0` | Silent memory layer bypass |
| No query bypasses the routing ledger | `DQR-ROUTE-0` | Unlogged subsystem access |
| No weight adjustment from DEFERRED dispositions | `CFI-HUMAN0-0` | Ambiguous human signal treated as pressure |
| No axis weight below floor or above ceiling | `CFI-FLOOR-0` / `CFI-CEIL-0` | Runaway weight collapse or monopoly |

Every invariant violation raises a typed exception, terminates the operation, and generates a ledger entry. There is no silent failure path.

![Section Divider](docs/assets/readme/inline-divider.svg)

## By the numbers

| Metric | Value |
|:-------|:------|
| Version | `v10.8.0` · Phase `192` complete |
| Hard-class invariants | **547** — enforced fail-closed at runtime |
| Shipped innovations | **114** — INNOV-01 through INNOV-??? |
| Latest innovation | **INNOV-97 · ILV** — Invariant Lineage Verifier |
| Constitutional Evolution Loop | **16 steps** — deterministic, replayable |
| Specialist agents | **3** — Architect · Dream · Beast |
| HUMAN-0 gate | **1** — non-delegatable, architecturally enforced |
| Append-only ledger entries | **48,000+** |
| Test files | **680+** |
| Governance artifacts | **249+** committed JSON attestations |
| PyPI | `adaad-core==9.121.0` |
| GitHub App | ADAADchat — webhook bridge + slash commands |
| V10 GA | Released — `v10.8.0` tagged · `v10.8.0` current |
| Platforms | Linux · macOS · Windows · Android · Docker |

![Section Divider](docs/assets/readme/inline-divider.svg)

## <a id="quickstart"></a>Quickstart

```bash
git clone https://github.com/InnovativeAI-adaad/ADAAD.git
cd ADAAD
python onboard.py
```

`onboard.py` handles environment setup, schema validation, and a governed dry-run.

```
  ✔ Python 3.12.x
  ✔ Virtual environment created (.venv)
  ✔ Dependencies installed
  ✔ Governance schemas valid
  ✔ Dry-run complete  (fail-closed behaviour confirmed)

  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  ADAAD is ready.

  Run the dashboard       python server.py
  Run an epoch            adaad demo
  Inspect the ledger      adaad inspect-ledger data/evolution_ledger.jsonl
  Propose a mutation      adaad propose "upgrade system x"
  Strict replay           python -m app.main --replay strict --verbose
  Verify the audit box    docker compose up das-demo
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
```

**Install from PyPI:**

```bash
pip install adaad
```

**Android / Termux:** Full governed runtime on a $200 phone. See [`TERMUX_SETUP.md`](TERMUX_SETUP.md).

![Section Divider](docs/assets/readme/inline-divider.svg)

## <a id="architecture"></a>Architecture

```
adaad/
├── adaad/core/                       # Governance-critical primitives (adaad-core PyPI package)
├── runtime/evolution/                # 16-step CEL implementation
├── dorkllm/                          # Full mutation pipeline + DORK intelligence stack
│   ├── mutation_selection_engine.py      # MSE — candidate scoring and selection
│   ├── mutation_risk_profiler.py         # MRP — pre-execution risk assessment
│   ├── mutation_phylogeny_graph.py       # MPG — lineage mapping
│   ├── mutation_execution_engine.py      # MEX — sandboxed execution
│   ├── mutation_fitness_verifier.py      # MFV — post-execution fitness verdict
│   ├── innovation_impact_scorer.py       # IIS — per-invariant delta scoring
│   ├── constitutional_adaptive_learner.py# CAL — amendment recommendation
│   ├── recommendation_delivery_protocol.py # RDP — HUMAN-0 delivery + disposition
│   ├── cfi_feedback_integrator.py        # CFI — disposition→weight feedback loop
│   ├── query_router.py                   # DQR — constitutional query router
│   ├── memory_engine.py                  # DPM — session-agnostic memory
│   ├── grounded_responder.py             # RAGS — corpus-grounded responses
│   └── constitutional_integrity_ledger.py # CIL — cross-ledger integrity attestation
├── security/ledger/                  # Tamper-evident hash-chained evolution ledger
├── app/main.py                       # Full autonomous loop orchestrator
├── ui/dork.html                      # DORK governance intelligence dashboard
├── server.py                         # API server (POST /api/dork/stream)
├── artifacts/governance/             # Per-phase sign-off and attestation artifacts
└── docs/                             # Full documentation corpus
```

![Section Divider](docs/assets/readme/inline-divider.svg)

## Who ADAAD is for

| Audience | What they get |
|:---------|:--------------|
| **AI safety researchers** | A production-running cryptographically evidenced autonomous governance loop — not a prototype |
| **Autonomous systems engineers** | Reference architecture for constitutional self-modification with full replay capability |
| **Governance architects** | 547 Hard-class invariants mapped to real operational guarantees, all independently verifiable |
| **Indie devs on Android** | Full governed runtime on a $200 phone — [`TERMUX_SETUP.md`](TERMUX_SETUP.md) |
| **Constitutional AI contributors** | Open governed amendment pipeline — all contributions traverse the CEL |
| **Patent / IP practitioners** | Novel mechanisms with documented prior art absence and replayable cryptographic evidence |

![Section Divider](docs/assets/readme/inline-divider.svg)

## Verifiable claims

Every governance claim in this repository has a corresponding ledger entry. Every ledger entry is hash-chained. Nothing requires you to trust the vendor.

Run the deterministic audit sandbox yourself:

```bash
docker compose up das-demo
```

Or verify the ledger directly:

```bash
make audit
```

Full verification corpus: [docs/VERIFIABLE_CLAIMS.md](docs/VERIFIABLE_CLAIMS.md)

![Section Divider](docs/assets/readme/inline-divider.svg)

## Platform support

| Platform | Status | Notes |
|:---------|:-------|:------|
| Linux (x86_64, ARM64) | ✅ Production | Primary target |
| macOS | ✅ Supported | Python 3.12 via Homebrew |
| Windows | ✅ Supported | PowerShell `.venv\Scripts\Activate.ps1` |
| Android (Termux) | ✅ Supported | Full runtime — see [`TERMUX_SETUP.md`](TERMUX_SETUP.md) |
| Docker | ✅ Supported | Pinned digest required — `:latest` prohibited by `DAS-DOCKER-0` |

![Section Divider](docs/assets/readme/inline-divider.svg)

## Governance model

ADAAD governs itself through its own [Constitution](docs/CONSTITUTION.md) — a versioned, GPG-signed document tracked in the Constitution Version Registry. Every constitutional amendment traverses the same CEL as every mutation.

**HUMAN-0** (Dustin L. Reid, InnovativeAI LLC) holds exclusive authority over GPG signing, Tier-0 ratification, and constitutional amendments. This role cannot be delegated. It cannot be automated. It is a constitutional primitive — not a policy.

![Section Divider](docs/assets/readme/inline-divider.svg)

## Intellectual property

ADAAD's core mechanisms — the Constitutional Evolution Loop, Cryptographic Evolution Proof DAG, Live Shadow Mutation Execution, Adversarial Fitness Red Team, Self-Proposing Innovation Engine, Retrieval-Augmented Governance Synthesis, DORK Persistent Memory, Dork Query Router, and CEL Feedback Integrator — are novel, patent-pending inventions of InnovativeAI LLC.

This software is proprietary and confidential. © 2025–2026 InnovativeAI LLC. All rights reserved. No use, reproduction, or distribution without written permission from InnovativeAI LLC. See [LICENSE](LICENSE), [BRAND_LICENSE.md](BRAND_LICENSE.md), and [TRADEMARKS.md](TRADEMARKS.md).

![Section Divider](docs/assets/readme/inline-divider.svg)

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md). All contributions traverse the CEL — your pull request does not bypass the pipeline.

Community constitutional amendment proposals go through the governed pipeline. See [CONSTITUTION_PROPOSALS.md](CONSTITUTION_PROPOSALS.md).

![Section Divider](docs/assets/readme/inline-divider.svg)

## V10.0.0 — Released

V10.0.0 was tagged on 2026-05-24. `v10.8.0` is the current release. All seven V10 convergence criteria were verified by the GA Promotion Engine (INNOV-92 · GPE) and sealed by the Governance Tag Certifier (INNOV-93 · GTC). The v9→v10 epoch boundary was sealed by the V10 Epoch Transition Engine (INNOV-94 · V10ET). The Constitutional Integrity Ledger (INNOV-96 · CIL) provides cross-ledger HMAC-chain attestation. The Invariant Lineage Verifier (INNOV-97 · ILV) traces causal ancestry chains across all 547 Hard-class invariants.

| Criterion | Status |
|:----------|:-------|
| CEL Wire integrity | ✅ Complete |
| Constitutional invariant coverage | ✅ 547 enforced |
| Ledger chain verification | ✅ HMAC chain verified |
| Replay determinism | ✅ Verified |
| AFRT adversarial coverage | ✅ Complete |
| adaad-core PyPI publish | ✅ `9.121.0` |
| GA_ALIGNMENT (GPE assessment) | ✅ Sealed by GTC — epoch boundary closed by V10ET |
| Invariant lineage tracing (ILV) | ✅ INNOV-97 · Phase 197 complete |
| Invariant lineage tracing (ILV) | ✅ INNOV-97 · Phase 197 complete |

![Section Divider](docs/assets/readme/inline-divider.svg)

## Links

| Resource | URL |
|:---------|:----|
| Homepage | [adaad.pro](https://adaad.pro) |
| DORK Dashboard | [aponi.adaad.pro](https://aponi.adaad.pro) |
| API | [api.adaad.pro](https://api.adaad.pro) |
| Documentation | [docs.adaad.pro](https://docs.adaad.pro) |
| PyPI | [pypi.org/project/adaad](https://pypi.org/project/adaad) |
| GitHub | [github.com/InnovativeAI-adaad/ADAAD](https://github.com/InnovativeAI-adaad/ADAAD) |
| GitHub App | [github.com/apps/adaadchat](https://github.com/apps/adaadchat) |
| adaad-core (PyPI) | [pypi.org/project/adaad-core](https://pypi.org/project/adaad-core) |
| LinkedIn | [linkedin.com/in/innovative-ai-a472513b5](https://www.linkedin.com/in/innovative-ai-a472513b5) |
| Telegram | [t.me/InnovativeAI_adaad](https://t.me/InnovativeAI_adaad) |

![Section Divider](docs/assets/readme/inline-divider.svg)

<div align="center">

**Built by [InnovativeAI LLC](https://adaad.pro) · Proprietary · © 2025–2026 InnovativeAI LLC · [adaad.pro](https://adaad.pro)**

---

*AI should evolve — but only under a constitution, with evidence, and with a human at the center.*

</div>
