fable-engine 1.3.1__tar.gz

fable_engine-1.3.1/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 REX-codebase contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

fable_engine-1.3.1/MANIFEST.in

@@ -0,0 +1,7 @@
+include LICENSE
+include fable_compressor.py
+include fable_engine/fable_session.json
+include fable_mode/resources.json
+recursive-include skills *
+recursive-include rules *
+recursive-include docs *

fable_engine-1.3.1/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.2
+Name: fable-engine
+Version: 1.3.1
+Summary: Independent deterministic System 2 cognitive engine and mechanical time-lock MCP server
+Author: REX-codebase
+License: MIT License
+        
+        Copyright (c) 2026 REX-codebase contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+        
+Project-URL: Homepage, https://github.com/REX-codebase/fable-mode
+Project-URL: Repository, https://github.com/REX-codebase/fable-mode
+Project-URL: Issues, https://github.com/REX-codebase/fable-mode/issues
+Keywords: mcp,ai-agents,coding-agents,verification,red-team,llm-tools
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: requires-python
+
+<div align="center">
+
+<br/>
+
+<img src="./assets/logo-light-mode.svg" width="120" alt="Fable Mode"/>
+
+# Fable Mode
+
+**Agents that think before they write.**
+
+<br/>
+
+<a href="https://github.com/REX-codebase/fable-mode"><img src="https://img.shields.io/badge/python-3.10%2B-black" alt="Python 3.10+"/></a>
+&nbsp;
+<a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-black" alt="MIT"/></a>
+&nbsp;
+<a href="https://modelcontextprotocol.io"><img src="https://img.shields.io/badge/protocol-MCP-black" alt="MCP"/></a>
+&nbsp;
+<img src="https://img.shields.io/badge/dependencies-0-black" alt="Zero Dependencies"/>
+&nbsp;
+<img src="https://img.shields.io/badge/tests-473%20passing-black" alt="473 tests passing"/>
+
+<br/><br/>
+
+</div>
+
+---
+
+<br/>
+
+Fable Mode is an open-source control plane for AI coding agents.
+
+It makes an agent deliberate, produce evidence, and survive adversarial review
+**before** it earns permission to write to your workspace. The gates are
+mechanical, not prompt advice: no timer, no proof, no write access.
+
+<br/>
+
+<div align="center">
+  <img src="./assets/flow-simple.svg" width="720" alt="Think → Prove → Attack → Write"/>
+</div>
+
+<div align="center">
+  <video src="https://github.com/REX-codebase/fable-mode/raw/main/assets/launch-film.mp4" width="720" controls muted loop playsinline></video>
+</div>
+
+<br/>
+
+### See it work
+
+A session starts locked. Confidence does not unlock it.
+
+```text
+>>> session = create_session('demo-refactor', budget='2 min')
+    state=INIT  execution_locked=True  can_execute_code=False
+
+>>> session.unlock_execution('the plan looks fine, let me write code now')
+    PermissionError: HARD TIME-LOCK VIOLATION: Execution unlock rejected!
+    The immutable 2.0m authority budget has not elapsed yet
+    (Remaining: 1m 59s / 120.0s).
+```
+
+The same gates guard every phase: evidence receipts for claims, a five-vector
+red-team swarm for code, and a sealed record of what was verified.
+
+<br/>
+
+### Install
+
+```bash
+pip install fable-engine
+```
+
+Point your agent at the MCP server:
+
+```jsonc
+// Claude Code: claude mcp add fable-engine -- python -m fable_engine.server
+// Cursor: ~/.cursor/mcp.json
+{
+  "mcpServers": {
+    "fable-engine": {
+      "command": "python",
+      "args": ["-m", "fable_engine.server"]
+    }
+  }
+}
+```
+
+Python 3.10+, zero runtime dependencies. PyPI package publishing is in progress.
+
+<br/>
+
+### How it works
+
+1. **Think** — Time-locked deliberation. The agent cannot write until the timer ends.
+2. **Prove** — Claims need real evidence (tool receipts, hashes, invariants).
+3. **Attack** — A red-team swarm tries to break the code.
+4. **Write** — Only then is the workspace unlocked.
+
+<br/>
+
+### What it is not
+
+- Not a claim of flawless code. It is a checkable workflow, not a guarantee.
+- Not a bigger prompt. The locks are enforced by the engine, not by wording.
+- Not a framework lock-in. It speaks MCP and runs beside your current agent.
+
+<br/>
+
+### Docs
+
+- [V1 → V2 migration](./docs/fable-v1-v2-migration.md)
+- [V2 architecture](./docs/fable-v2-architecture.md)
+- [System 3 (experimental)](./docs/system3-architecture.md)
+
+<br/>
+
+### Contributing
+
+Issues and pull requests are welcome. See [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+<br/>
+
+---
+
+<div align="center">
+
+<sub>MIT License · Built by REX</sub>
+
+</div>

fable_engine-1.3.1/README.md

@@ -0,0 +1,130 @@
+<div align="center">
+
+<br/>
+
+<img src="./assets/logo-light-mode.svg" width="120" alt="Fable Mode"/>
+
+# Fable Mode
+
+**Agents that think before they write.**
+
+<br/>
+
+<a href="https://github.com/REX-codebase/fable-mode"><img src="https://img.shields.io/badge/python-3.10%2B-black" alt="Python 3.10+"/></a>
+&nbsp;
+<a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-black" alt="MIT"/></a>
+&nbsp;
+<a href="https://modelcontextprotocol.io"><img src="https://img.shields.io/badge/protocol-MCP-black" alt="MCP"/></a>
+&nbsp;
+<img src="https://img.shields.io/badge/dependencies-0-black" alt="Zero Dependencies"/>
+&nbsp;
+<img src="https://img.shields.io/badge/tests-473%20passing-black" alt="473 tests passing"/>
+
+<br/><br/>
+
+</div>
+
+---
+
+<br/>
+
+Fable Mode is an open-source control plane for AI coding agents.
+
+It makes an agent deliberate, produce evidence, and survive adversarial review
+**before** it earns permission to write to your workspace. The gates are
+mechanical, not prompt advice: no timer, no proof, no write access.
+
+<br/>
+
+<div align="center">
+  <img src="./assets/flow-simple.svg" width="720" alt="Think → Prove → Attack → Write"/>
+</div>
+
+<div align="center">
+  <video src="https://github.com/REX-codebase/fable-mode/raw/main/assets/launch-film.mp4" width="720" controls muted loop playsinline></video>
+</div>
+
+<br/>
+
+### See it work
+
+A session starts locked. Confidence does not unlock it.
+
+```text
+>>> session = create_session('demo-refactor', budget='2 min')
+    state=INIT  execution_locked=True  can_execute_code=False
+
+>>> session.unlock_execution('the plan looks fine, let me write code now')
+    PermissionError: HARD TIME-LOCK VIOLATION: Execution unlock rejected!
+    The immutable 2.0m authority budget has not elapsed yet
+    (Remaining: 1m 59s / 120.0s).
+```
+
+The same gates guard every phase: evidence receipts for claims, a five-vector
+red-team swarm for code, and a sealed record of what was verified.
+
+<br/>
+
+### Install
+
+```bash
+pip install fable-engine
+```
+
+Point your agent at the MCP server:
+
+```jsonc
+// Claude Code: claude mcp add fable-engine -- python -m fable_engine.server
+// Cursor: ~/.cursor/mcp.json
+{
+  "mcpServers": {
+    "fable-engine": {
+      "command": "python",
+      "args": ["-m", "fable_engine.server"]
+    }
+  }
+}
+```
+
+Python 3.10+, zero runtime dependencies. PyPI package publishing is in progress.
+
+<br/>
+
+### How it works
+
+1. **Think** — Time-locked deliberation. The agent cannot write until the timer ends.
+2. **Prove** — Claims need real evidence (tool receipts, hashes, invariants).
+3. **Attack** — A red-team swarm tries to break the code.
+4. **Write** — Only then is the workspace unlocked.
+
+<br/>
+
+### What it is not
+
+- Not a claim of flawless code. It is a checkable workflow, not a guarantee.
+- Not a bigger prompt. The locks are enforced by the engine, not by wording.
+- Not a framework lock-in. It speaks MCP and runs beside your current agent.
+
+<br/>
+
+### Docs
+
+- [V1 → V2 migration](./docs/fable-v1-v2-migration.md)
+- [V2 architecture](./docs/fable-v2-architecture.md)
+- [System 3 (experimental)](./docs/system3-architecture.md)
+
+<br/>
+
+### Contributing
+
+Issues and pull requests are welcome. See [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+<br/>
+
+---
+
+<div align="center">
+
+<sub>MIT License · Built by REX</sub>
+
+</div>

fable_engine-1.3.1/docs/fable-v1-v2-migration.md

@@ -0,0 +1,44 @@
+# Fable V1 to V2 Migration & Integration Guide
+
+## Overview of Entry Points
+
+| Entry Point | Version | Purpose |
+|---|---|---|
+| `fable-engine` | V1 | Main `fable_session` MCP server from `fable_engine.server` |
+| `fable-v1` | V1 | Explicit alias for `fable-engine` |
+| `fable-v2-broker` | V2 | Out-of-process workspace execution broker from `fable_v2.execution_broker` |
+
+The `install.sh` and `install.ps1` scripts register the V1 `fable-engine` MCP server by default for backward compatibility with existing MCP clients. Installing the Python package (`pip install -e .`) registers the `fable-v2-broker` executable without replacing the V1 MCP server.
+
+---
+
+## V2 Execution Broker Setup
+
+Start the V2 execution broker specifying its managed workspace:
+
+```bash
+fable-v2-broker --workspace /path/to/workspace
+```
+
+### Authorization & Control Pipe
+- The broker loads write authorization digest from the `FABLE_BROKER_WRITE_TOKEN_DIGEST` environment variable or `FABLE_BROKER_WRITE_TOKEN_DIGEST_FILE` file. This value is a SHA-256 digest of an administrative token.
+- Unlocking write permissions requires communicating over a dedicated administrative control descriptor (`--admin-fd` on POSIX). The model-facing JSON-lines channel cannot issue unlock commands directly.
+- Host integration adapters should keep administrative file descriptors isolated from model tool definitions.
+
+### Process & Path Restrictions
+- The broker allowlists permitted executables and runs commands without shell invocation (`shell=False`).
+- Working directories and file writes are constrained to the designated workspace.
+- Interpreter execution is restricted while writes are locked to prevent inline write bypasses.
+
+> **Security Note:** The broker operates as a process and policy boundary. For untrusted code execution, run the broker inside a container or sandboxed OS environment with restricted permissions.
+
+---
+
+## Migration Sequence for Hosts & Adapters
+
+1. **Keep V1 MCP Enabled:** Maintain the `fable-engine` MCP server active during initial adapter testing.
+2. **Launch V2 Broker:** Start `fable-v2-broker` with its dedicated workspace directory.
+3. **Probe Host Capabilities:** Query host capabilities at runtime and verify attested features.
+4. **Issue Tool Receipts:** Route V2 command executions and file operations through the broker to generate `ToolReceipt` objects.
+5. **Enforce Verification Policies:** Enable candidate finalization once verifier checks pass.
+6. **Final Transition:** Disable legacy V1 tools only after validating V2 execution broker flows in your environment.

fable_engine-1.3.1/docs/fable-v2-architecture.md

@@ -0,0 +1,93 @@
+# Fable V2: Portable Verifier-Guided Runtime
+
+## Goal
+
+Fable V2 is a portable, model-agnostic intelligence runtime designed to work across AI agent hosts such as Antigravity, Claude Code, Cursor, OpenAI Codex, and others. Fable V2 aims to make coding models more reliable, consistent, and effective on verifiable software engineering tasks.
+
+Rather than relying on unverified model assertions, Fable V2 coordinates models, tools, evidence receipts, search strategies, and verification policies.
+
+## Design Principle
+
+> Do not rely on an agent's unverified claim that work was performed correctly. Require the runtime to collect execution receipts, run verification checks, and accept only evidence-backed artifacts.
+
+MCP serves as an interface and transport layer. Fable V2 provides the runtime around it: execution broker, evidence ledger, model router, candidate manager, verifier broker, and repair loops.
+
+## Architecture
+
+```text
+User task
+   |
+   v
+TaskSpec: objective, constraints, done conditions, required capabilities
+   |
+   v
+Budget + model router ---- host capability probe
+   |
+   v
+Diverse candidate fleet ---- tools / sandbox / execution broker
+   |
+   v
+ToolReceipts & Evidence integrity ledger
+   |
+   v
+Deterministic verifiers -> independent model verifiers -> repair/search loop
+   |
+   v
+Finalization gate: accepts only passing, evidence-backed candidates
+```
+
+## Portable Core and Adapters
+
+The core speaks a host-neutral JSON data contract (`fable_v2/protocol.py`). Adapters translate native host tools into standard capabilities such as `inspect_files`, `execute_command`, `run_tests`, `search_web`, `edit_files`, and `delegate_agents`.
+
+Supported integrations are implemented as thin adapters. MCP is the primary tool binding, while CLI or HTTP interfaces accommodate hosts without native MCP support.
+
+## Execution Boundary (`fable-v2-broker`)
+
+`fable_v2.execution_broker` provides an isolated execution boundary for V2:
+- Runs as a separate process (`fable-v2-broker`).
+- Restricts executables via allowlists and runs commands without shell invocation.
+- Constrains file operations and workspace paths.
+- Keeps workspace file writes locked until administrative authorization.
+- Blocks interactive interpreter bypasses while writes are locked.
+- Accepts administrative unlock commands over a separate control handle (`--admin-fd` on POSIX) that is isolated from model input channels.
+
+> **Security Note:** The broker is a process and policy boundary. Hostile or untrusted workloads should be executed within container or OS-level virtualized sandboxes with restricted permissions.
+
+## Enforcement Model
+
+### 1. Invocation Is Not Correctness
+A `ToolReceipt` confirms that a tool was executed and captures its raw output hash. A successful `pytest` receipt proves test execution, but does not inherently guarantee overall solution correctness. Correctness is established by the configured `VerificationPolicy`.
+
+### 2. Receipt and Evidence Integrity
+Each tool execution generates a `ToolReceipt` containing:
+- Session and tool identifiers
+- Capability classification
+- Hashes of tool input and output
+- Execution status and timestamps
+
+`Evidence` is constructed from receipts using `Evidence.from_receipt(...)`. Content hashes are verified to prevent tampering or mismatched output claims.
+
+### 3. Policy-Enforced Verification
+Finalization requires satisfying the `VerificationPolicy`:
+- Verification verdicts are runtime-attested and bound to specific candidate artifact hashes.
+- Verification commitments include candidate state and referenced receipt/evidence hashes.
+- Deterministic checks (linters, test runners, type checkers) execute prior to model-based judges.
+
+## Runtime Objects (`fable_v2/protocol.py`)
+
+- `TaskSpec`: Task contract, objectives, required capabilities, and definition of done.
+- `VerificationPolicy`: Required verifier classes and passing thresholds.
+- `ToolReceipt`: Invocation receipt containing input/output hashes and execution metadata.
+- `Evidence`: Provenance-backed claim constructed from a valid `ToolReceipt`.
+- `Candidate`: A specific solution trajectory or artifact.
+- `VerificationResult`: Runtime-attested verdict bound to a candidate artifact.
+
+## Quality & Verification Rules
+
+1. **No Self-Attested Verification:** Claims must be backed by tool execution receipts.
+2. **Deterministic Before Model Verification:** Machine checks run prior to model judges.
+3. **Independent Review:** Generator and verifier components remain separate for complex tasks.
+4. **Targeted Repair:** Failed verification attempts yield structured failure classifications for targeted iteration.
+5. **Gated Finalization:** Candidate finalization requires complete receipt and policy satisfaction.
+6. **Isolated Permission Enforcer:** Workspace permissions are enforced by the execution broker/sandbox boundary.

fable_engine-1.3.1/docs/system3-architecture.md

@@ -0,0 +1,122 @@
+# System 3 Meta-Cognitive Deliberation Architecture (Experimental)
+
+## 1. Executive Summary & Overview
+
+Fable Mode includes an experimental **System 3 Meta-Cognitive Deliberation Engine** (`fable_v2/system3/`), designed as a research extension to dual-process agent architectures (System 1 intuitive heuristics and System 2 deliberative search).
+
+System 3 operates above the solution generation loop. It provides tools for modeling structural causal dependencies (Pearl's do-calculus), embedding architectural tree structures into Poincaré hyperbolic space, checking modal properties across state transition models (Kripke structures), evaluating policy uncertainty via Active Inference (Variational Free Energy), checking constructive proofs (Curry-Howard isomorphism), resolving parameter trade-offs via TRIZ principles, and searching architectural trade-off spaces.
+
+> **Note on status:** System 3 capabilities in `fable_v2/system3/` are experimental research modules. They provide specialized mathematical and logical tools accessible through the `fable_session` MCP interface or direct Python APIs.
+
+---
+
+## 2. Tri-Level Cognitive Hierarchy
+
+```text
+┌────────────────────────────────────────────────────────────────────────────────┐
+│                   SYSTEM 3: META-COGNITIVE & LOGICAL REASONING                 │
+│  - Pearl Do-Calculus Causal Models (DAG, Interventions, Brittleness Analysis) │
+│  - Poincaré Hyperbolic Manifold Embeddings (Exact Metric, Möbius Gyrovectors) │
+│  - Kripke Modal Model Checker (CTL Temporal Logic: AG, EF, AF, AX, EU, AU)     │
+│  - Friston Active Inference (Variational F = Complexity - Accuracy, EFE G)   │
+│  - Gödelian Proof Oracle & Curry-Howard Constructive Type Verification        │
+│  - Dialectical Triad & 40 TRIZ Inventive Contradiction Resolution             │
+│  - Evolutionary Paradigm Engine (10D Pareto Frontier NSGA-II Optimization)    │
+│  - Neuro-Symbolic Invariant Induction (Empirical Falsification)               │
+└──────────────────────────────────────┬─────────────────────────────────────────┘
+                                       │ (Gear Arbitration)
+                                       ▼
+┌────────────────────────────────────────────────────────────────────────────────┐
+│                         SYSTEM 2: DELIBERATIVE REASONING                       │
+│  - Structured Deliberation Chains & Time-Locked Execution                     │
+│  - Adversarial Red-Teaming & Falsification Probes                             │
+│  - Formal Invariant Modeling & Domain Specification                           │
+│  - Continuous Rethink-Refine Loop                                             │
+└──────────────────────────────────────┬─────────────────────────────────────────┘
+                                       │ (Execution Delegation)
+                                       ▼
+┌────────────────────────────────────────────────────────────────────────────────┐
+│                       SYSTEM 1: INTUITIVE & PROCEDURAL EXECUTION               │
+│  - Fast Pattern Matching & Code Generation via Subagent Fleet                  │
+│  - Deterministic Machine Verification & Tool Receipts                          │
+│  - Local Error Recovery & Repair Loops                                         │
+└────────────────────────────────────────────────────────────────────────────────┘
+```
+
+### Cognitive Gear Arbitration
+
+The `TriLevelArbitrator` evaluates task complexity, contradiction metrics, failure counts, and epistemic uncertainty to suggest operating gears:
+
+1. **`SYSTEM_1_INTUITIVE`**: Selected for low-complexity, procedural, non-conflicting tasks.
+2. **`SYSTEM_2_DELIBERATIVE`**: Selected for medium-complexity tasks requiring deep decomposition, formal invariants, and red-team review.
+3. **`SYSTEM_3_META_COGNITIVE`**: Engaged when high contradiction density or repeated test failures occur, engaging causal simulation, hyperbolic embeddings, modal checking, or proof oracles.
+
+---
+
+## 3. Hyperbolic Geometry (`fable_v2.system3.hyperbolic`)
+
+Tree hierarchies and software dependency graphs can suffer distortion when embedded into Euclidean spaces. System 3 provides Poincaré Ball embeddings ($\mathbb{B}^n_c = \{x \in \mathbb{R}^n : c \|x\|^2 < 1\}$) to represent deep hierarchical tree structures with bounded distance metric distortion.
+
+---
+
+## 4. Kripke Modal Model Checker (`fable_v2.system3.kripke`)
+
+System 3 implements verification of state machines and concurrent transitions using **Kripke Structures** $M = \langle W, R, L, W_0 \rangle$ and **Computation Tree Logic (CTL)**:
+
+- **Safety Invariants ($AG \phi$):** Checks if property $\phi$ holds across all reachable states. Generates counterexample trace paths when violated.
+- **Reachability ($EF \phi$):** Verifies if a desired state $\phi$ is reachable from initial states. Generates witness paths upon success.
+
+---
+
+## 5. Active Inference & Free Energy (`fable_v2.system3.free_energy`)
+
+Implements Karl Friston's **Free Energy Principle** to model agent perception and action selection under uncertainty:
+
+- **Variational Free Energy ($F$):** Evaluates complexity vs. accuracy metrics over hidden architectural states.
+- **Expected Free Energy ($G$):** Balances pragmatic cost (goal divergence) and epistemic value (information gain) for policy selection.
+
+---
+
+## 6. Curry-Howard Proof Oracle (`fable_v2.system3.oracle`)
+
+Bridges logical assertions and type checking via the **Curry-Howard Isomorphism** (Propositions-as-Types):
+
+- **Type Checker:** Evaluates bidirectional type checking ($\Gamma \vdash t : T$) for constructive propositions.
+- **Undecidability Detector:** Identifies circular references, cyclical negations, and self-referential paradoxes, returning classifications (`DECIDABLE_PROVED`, `DECIDABLE_REFUTED`, `INDEPENDENT_UNDECIDABLE`, `COMPLEXITY_EXCEEDED`).
+
+---
+
+## 7. Causal Simulation & Pearl's Do-Calculus (`fable_v2.system3.causal`)
+
+- **Graph Interventions (`do(X = x)`):** Simulates structural causal graph modifications and measures counterfactual deltas.
+- **Sensitivity Analysis:** Identifies single points of failure (SPOFs) and fragile nodes in dependency graphs.
+
+---
+
+## 8. Dialectical Synthesis & TRIZ Matrix (`fable_v2.system3.dialectical`)
+
+- Maps parameter trade-offs (e.g., speed vs. safety) to TRIZ inventive principles (Segmentation, Extraction, Local Quality, Prior Action, Inversion).
+- `DialecticalSynthesizer` runs bounded debate iterations to resolve contradictions.
+
+---
+
+## 9. Evolutionary Paradigm Engine (`fable_v2.system3.evolution`)
+
+Optimizes candidate architectures across up to 10 quality dimensions (Latency, Throughput, Memory, Fault Tolerance, Modularity, Simplicity, Testability, Security, Determinism, Token Efficiency) using non-dominated sorting.
+
+---
+
+## 10. MCP Tool Integration (`fable_session`)
+
+System 3 capabilities are exposed through `fable_session` MCP actions:
+
+| Action | Description | Parameters |
+|---|---|---|
+| `system3_hyperbolic_embed` | Poincaré ball tree embedding | `tree`, `root_id`, `dimension`, `curvature` |
+| `system3_kripke_verify` | Kripke model checking with CTL formulas | `worlds`, `transitions`, `formula`, `initial_world` |
+| `system3_active_inference` | Variational Free Energy $F$ & EFE $G$ | `observation`, `policies`, `gamma`, `states` |
+| `system3_proof_oracle` | Curry-Howard proof verification | `claim`, `context`, `axioms` |
+| `system3_dialectical_synthesis` | Dialectical debate & TRIZ resolution | `thesis_title`, `antithesis_title`, `contradictions` |
+| `system3_causal_simulate` | Causal DAG intervention & sensitivity | `nodes`, `edges`, `interventions`, `target_metric` |
+| `system3_evolve_paradigms` | Pareto frontier genetic optimization | `generations`, `population_size`, `mutation_rate` |
+| `system3_tri_level_orchestrate` | Cognitive gear arbitration | `task_complexity`, `contradiction_density`, `failure_count` |