fable-engine 1.3.1__py3-none-any.whl

fable_mode/resources.json

@@ -0,0 +1,114 @@
+{
+  "format": 1,
+  "files": [
+    "fable_mode/__init__.py",
+    "fable_mode/__main__.py",
+    "fable_mode/adapters.py",
+    "fable_mode/installer.py",
+    "fable_mode/launcher.py",
+    "fable_mode/manifest.py",
+    "fable_mode/safety.py",
+    "fable_mode/resources.json",
+    "fable_engine/__init__.py",
+    "fable_engine/browser.py",
+    "fable_engine/actions/__init__.py",
+    "fable_engine/actions/cas.py",
+    "fable_engine/actions/deliberation.py",
+    "fable_engine/actions/fleet.py",
+    "fable_engine/actions/lifecycle.py",
+    "fable_engine/actions/scrapers.py",
+    "fable_engine/actions/system3.py",
+    "fable_engine/cas.py",
+    "fable_engine/scrapers/__init__.py",
+    "fable_engine/scrapers/arxiv.py",
+    "fable_engine/scrapers/base.py",
+    "fable_engine/scrapers/github.py",
+    "fable_engine/scrapers/reddit.py",
+    "fable_engine/scrapers/web.py",
+    "fable_engine/scrapers/x.py",
+    "fable_engine/scrapers/youtube.py",
+    "fable_engine/guards.py",
+    "fable_engine/schema.py",
+    "fable_engine/server.py",
+    "fable_engine/session.py",
+    "fable_engine/updater.py",
+    "fable_engine/fable_session.json",
+    "fable_v2/__init__.py",
+    "fable_v2/adapters.py",
+    "fable_v2/execution_broker.py",
+    "fable_v2/protocol.py",
+    "fable_v2/runtime.py",
+    "fable_v2/system3/__init__.py",
+    "fable_v2/system3/causal.py",
+    "fable_v2/system3/dialectical.py",
+    "fable_v2/system3/evolution.py",
+    "fable_v2/system3/executive.py",
+    "fable_v2/system3/free_energy.py",
+    "fable_v2/system3/hyperbolic.py",
+    "fable_v2/system3/induction.py",
+    "fable_v2/system3/kripke.py",
+    "fable_v2/system3/oracle.py",
+    "fable_v2/verifiers.py",
+    "fable_v2/proof_engine.py",
+    "fable_v2/coder_fleet/__init__.py",
+    "fable_v2/coder_fleet/ast_tools.py",
+    "fable_v2/coder_fleet/compute.py",
+    "fable_v2/coder_fleet/diagnostics.py",
+    "fable_v2/coder_fleet/fleet_dispatcher.py",
+    "fable_v2/coder_fleet/mock_auditor.py",
+    "fable_v2/coder_fleet/mutation.py",
+    "fable_v2/coder_fleet/property_oracle.py",
+    "fable_v2/coder_fleet/receipt_attestor.py",
+    "fable_v2/coder_fleet/test_harness.py",
+    "fable_v2/coder_fleet/visual.py",
+    "fable_v2/coder_fleet/workspace.py",
+    "fable_v2/coder_fleet/red_team_swarm.py",
+    "fable_v2/coder_fleet/vector_engine.py",
+    "fable_v2/coder_fleet/design_engine.py",
+    "fable_v2/cortical/__init__.py",
+    "fable_v2/cortical/plasticity_engine.py",
+    "fable_compressor.py",
+    "run_tests.py",
+    "rules/AGENTS.md",
+    "rules/GEMINI.md",
+    "rules/fable-mode.md",
+    "docs/fable-v2-architecture.md",
+    "docs/fable-v1-v2-migration.md",
+    "docs/system3-architecture.md",
+    "skills/fable-mode/SKILL.md",
+    "skills/fable-mode/examples/autonomous-agentic-migration.md",
+    "skills/fable-mode/examples/breakthrough-algorithm-synthesis.md",
+    "skills/fable-mode/examples/deepthink-analysis-proof.md",
+    "skills/fable-mode/examples/distributed-system-design.md",
+    "skills/fable-mode/examples/swe-bench-pro-debugging.md",
+    "skills/fable-mode/examples/weak_model_ollama_setup.md",
+    "skills/fable-mode/references/aaa-threejs-game-engine.md",
+    "skills/fable-mode/references/agentic-execution.md",
+    "skills/fable-mode/references/architectural-blueprinting.md",
+    "skills/fable-mode/references/cinematic-design-engine.md",
+    "skills/fable-mode/references/anti-slop-frontend-architecture.md",
+    "skills/fable-mode/references/cognitive-protocol.md",
+    "skills/fable-mode/references/deepthink-mode.md",
+    "skills/fable-mode/references/design-tokens-and-typographies.md",
+    "skills/fable-mode/references/goal-rubric-and-pipeline-automation.md",
+    "skills/fable-mode/references/innovation-engine.md",
+    "skills/fable-mode/references/interleaved-verification.md",
+    "skills/fable-mode/references/model-velocity-calibration.md",
+    "skills/fable-mode/references/prompt-scaffolds.md",
+    "skills/fable-mode/references/proof-architecture.md",
+    "skills/fable-mode/references/svg-craft-and-vector-design.md",
+    "skills/fable-mode/references/system2-session-engine.md",
+    "skills/fable-mode/references/system3-meta-cognition.md",
+    "skills/fable-mode/references/visual-imagination-engine.md",
+    "skills/fable-mode/references/weak-model-frontier-uplift.md",
+    "skills/fable-mode/references/adversarial-code-review-swarm.md",
+    "skills/fable-mode/references/hebbian-cortical-plasticity.md",
+    "skills/fable-mode/cortex/rust.md",
+    "skills/fable-mode/cortex/python.md",
+    "skills/fable-mode/cortex/design_3d.md",
+    "skills/fable-mode/cortex/frontend_design.md",
+    "skills/fable-mode/cortex/research.md",
+    "skills/fable-mode/cortex/concurrency.md",
+    "LICENSE"
+  ]
+}

fable_mode/safety.py

@@ -0,0 +1,103 @@
+"""Filesystem safety primitives shared by installer and registration."""
+from __future__ import annotations
+
+import os
+import shutil
+import stat
+import threading
+from pathlib import Path
+
+# A directory is eligible for recursive removal only after this process created
+# it (or moved an installer-owned install into it).  Ownership includes the
+# inode identity, so replacing the path after publication cannot turn cleanup
+# into deletion of an unrelated directory.
+_owned: dict[tuple[int, str], tuple[int, int]] = {}
+_lock = threading.Lock()
+
+
+def mark_owned_directory(path: Path) -> tuple[int, int]:
+    p = Path(path)
+    st = p.lstat()
+    if not stat.S_ISDIR(st.st_mode):
+        raise ValueError("owned path is not a directory")
+    identity = (st.st_dev, st.st_ino)
+    with _lock:
+        _owned[(os.getpid(), os.path.abspath(os.fspath(p)))] = identity
+    return identity
+
+
+def _is_owned(path: Path, st: os.stat_result) -> bool:
+    with _lock:
+        identity = _owned.get((os.getpid(), os.path.abspath(os.fspath(path))))
+    return identity == (st.st_dev, st.st_ino)
+
+
+def _forget(path: Path) -> None:
+    with _lock:
+        _owned.pop((os.getpid(), os.path.abspath(os.fspath(path))), None)
+
+
+def _unsafe_node(path: Path, st: os.stat_result) -> bool:
+    attrs = int(getattr(st, "st_file_attributes", 0))
+    return bool(attrs & 0x400) or stat.S_ISLNK(st.st_mode) or stat.S_ISSOCK(st.st_mode) or stat.S_ISFIFO(st.st_mode) or stat.S_ISCHR(st.st_mode) or stat.S_ISBLK(st.st_mode)
+
+
+def safe_cleanup(stage_dir: Path | None, *, expected_identity: tuple[int, ...] | None = None) -> None:
+    """Remove one freshly-created, process-owned private directory.
+
+    No path is resolved before lstat, and ownership is an in-memory capability,
+    not a pathname convention.  Thus a pre-existing ``.previous-*`` directory,
+    the cwd, a repository, a parent, or a symlink can never become a recursive
+    deletion target merely by having a plausible name.
+    """
+    if stage_dir is None:
+        return
+    p = Path(stage_dir)
+    if not p.is_absolute() or p in {Path("/"), Path.cwd().absolute()}:
+        raise ValueError("unsafe staging directory")
+    try:
+        st = p.lstat()
+    except FileNotFoundError:
+        _forget(p)
+        return
+    if expected_identity is None:
+        identity_ok = _is_owned(p, st)
+    else:
+        # A four-field capability additionally binds ownership.  The original
+        # two-field form remains supported for legacy callers/markers.
+        identity_ok = tuple(expected_identity[:2]) == (st.st_dev, st.st_ino)
+        if len(expected_identity) >= 4:
+            identity_ok = identity_ok and tuple(expected_identity[2:4]) == (st.st_uid, st.st_gid)
+    if identity_ok:
+        pass
+    else:
+        raise ValueError("unsafe or unowned staging directory")
+    if _unsafe_node(p, st) or not stat.S_ISDIR(st.st_mode):
+        raise ValueError("unsafe or unowned staging directory")
+    # Validate the complete tree without following links before removing it.
+    for root, dirs, files in os.walk(p, topdown=True, followlinks=False):
+        root_path = Path(root)
+        for name in (*dirs, *files):
+            child = root_path / name
+            child_st = child.lstat()
+            if _unsafe_node(child, child_st):
+                raise ValueError("unsafe node in staging directory")
+            if stat.S_ISREG(child_st.st_mode) and child_st.st_nlink != 1:
+                raise ValueError("hardlinked node in staging directory")
+    # Last pathname check immediately before recursive deletion.  This is a
+    # best-effort race mitigation (Python lacks portable descriptor-relative
+    # recursive delete), not a descriptor-perfect guarantee.
+    try:
+        final_st = p.lstat()
+    except FileNotFoundError:
+        _forget(p)
+        return
+    final_identity = (final_st.st_dev, final_st.st_ino)
+    expected = tuple(expected_identity[:2]) if expected_identity is not None else (st.st_dev, st.st_ino)
+    final_capability_ok = final_identity == expected
+    if expected_identity is not None and len(expected_identity) >= 4:
+        final_capability_ok = final_capability_ok and tuple(expected_identity[2:4]) == (final_st.st_uid, final_st.st_gid)
+    if not final_capability_ok or _unsafe_node(p, final_st) or not stat.S_ISDIR(final_st.st_mode):
+        raise ValueError("cleanup target changed before deletion")
+    shutil.rmtree(p)
+    _forget(p)

fable_mode_entry.py

@@ -0,0 +1,10 @@
+"""Frozen/source top-level wrapper; package imports remain valid in both modes."""
+import sys
+
+# Install trees have an exact file manifest; runtime probes must not create
+# unlisted __pycache__ artifacts beside the canonical source payload.
+sys.dont_write_bytecode = True
+from fable_mode.launcher import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fable_v2/__init__.py

@@ -0,0 +1,146 @@
+"""Experimental portable Fable V2 runtime with System 3 Meta-Cognitive Architecture."""
+
+from .adapters import HOST_PROFILES, HostCapabilities, get_profile
+from .execution_broker import BrokerPolicy, ExecutionBroker
+from .protocol import (
+    AutomationPipelineSpec,
+    Candidate,
+    Evidence,
+    FileChangeRecord,
+    GoalRubric,
+    GoalRubricItem,
+    ModelVelocityProfile,
+    ProofReceipt,
+    TaskSpec,
+    ToolReceipt,
+    VerificationPolicy,
+    VerificationResult,
+    VisualMockupSpec,
+)
+from .runtime import FableRun, RunState, new_run
+from .verifiers import CompositeVerifier, FunctionVerifier
+from .proof_engine import (
+    DeterministicProofValidator,
+    ProofStatus as EngineProofStatus,
+    ProofType,
+    ProofValidationResult,
+)
+from . import system3
+from .system3 import (
+    # System 3 Causal
+    CausalDAG,
+    CausalNode,
+    CausalEdge,
+    CausalNodeType,
+    BrittlenessReport,
+    InterventionResult,
+    # System 3 Dialectical
+    ThesisCandidate,
+    AntithesisCritique,
+    Contradiction,
+    TRIZPrinciple,
+    TRIZContradictionResolver,
+    DialecticalSynthesizer,
+    EmergentSynthesis,
+    # System 3 Evolution
+    CognitiveGenome,
+    CognitiveGenePool,
+    # System 3 Induction
+    NeuroSymbolicAxiom,
+    AxiomProvenance,
+    AxiomStatus,
+    MetaProofInducer,
+    # System 3 Executive
+    CognitiveGear,
+    CognitiveBiasType,
+    CognitiveBiasFinding,
+    CognitiveBiasDetector,
+    DynamicSearchHeuristicRewriter,
+    SearchHeuristicConfig,
+    TriLevelArbitrator,
+    System3Executive,
+    # System 3 Hyperbolic
+    PoincareBall,
+    HyperbolicPoint,
+    HyperbolicTreeEmbedder,
+    TreeEmbeddingNode,
+    TreeEmbeddingResult,
+    HyperbolicGeometryError,
+    # System 3 Kripke
+    KripkeStructure,
+    KripkeWorld,
+    KripkeModelChecker,
+    ModelCheckResult,
+    CTLOperator,
+    FormulaNode,
+    FormulaParser,
+    # System 3 Free Energy
+    ActiveInferenceEngine,
+    GenerativeModel,
+    Policy,
+    PolicyEvaluation,
+    FreeEnergyReport,
+    create_default_architecture_pomdp,
+    # System 3 Oracle
+    ProofOracle,
+    CurryHowardVerifier,
+    UndecidabilityDetector,
+    TacticsEngine,
+    FormalProofResult,
+    ProofStatus,
+    Type,
+    Term,
+    Prop,
+    Unit,
+    Void,
+    Implies,
+    And,
+    Or,
+    Not,
+    Eq,
+    Forall,
+    Exists,
+    Var,
+    Lam,
+    App,
+    Pair,
+    Fst,
+    Snd,
+    Inl,
+    Inr,
+    Case,
+    Refl,
+    Abort,
+)
+
+__all__ = [
+    "AutomationPipelineSpec", "BrokerPolicy", "Candidate", "CompositeVerifier", "Evidence",
+    "ExecutionBroker", "FableRun", "FileChangeRecord", "FunctionVerifier", "GoalRubric",
+    "GoalRubricItem", "HOST_PROFILES", "HostCapabilities", "ModelVelocityProfile",
+    "ProofReceipt", "RunState", "TaskSpec", "ToolReceipt", "VerificationPolicy",
+    "VerificationResult", "VisualMockupSpec",
+    "get_profile", "new_run", "DeterministicProofValidator",
+    "system3",
+    # System 3 Causal
+    "CausalDAG", "CausalNode", "CausalEdge", "CausalNodeType", "BrittlenessReport", "InterventionResult",
+    # System 3 Dialectical
+    "ThesisCandidate", "AntithesisCritique", "Contradiction", "TRIZPrinciple", "TRIZContradictionResolver",
+    "DialecticalSynthesizer", "EmergentSynthesis",
+    # System 3 Evolution
+    "CognitiveGenome", "CognitiveGenePool",
+    # System 3 Induction
+    "NeuroSymbolicAxiom", "AxiomProvenance", "AxiomStatus", "MetaProofInducer",
+    # System 3 Executive
+    "CognitiveGear", "CognitiveBiasType", "CognitiveBiasFinding", "CognitiveBiasDetector",
+    "DynamicSearchHeuristicRewriter", "SearchHeuristicConfig", "TriLevelArbitrator", "System3Executive",
+    # System 3 Hyperbolic
+    "PoincareBall", "HyperbolicPoint", "HyperbolicTreeEmbedder", "TreeEmbeddingNode", "TreeEmbeddingResult", "HyperbolicGeometryError",
+    # System 3 Kripke
+    "KripkeStructure", "KripkeWorld", "KripkeModelChecker", "ModelCheckResult", "CTLOperator", "FormulaNode", "FormulaParser",
+    # System 3 Free Energy
+    "ActiveInferenceEngine", "GenerativeModel", "Policy", "PolicyEvaluation", "FreeEnergyReport", "create_default_architecture_pomdp",
+    # System 3 Oracle
+    "ProofOracle", "CurryHowardVerifier", "UndecidabilityDetector", "TacticsEngine", "FormalProofResult", "ProofStatus",
+    "Type", "Term", "Prop", "Unit", "Void", "Implies", "And", "Or", "Not", "Eq", "Forall", "Exists",
+    "Var", "Lam", "App", "Pair", "Fst", "Snd", "Inl", "Inr", "Case", "Refl", "Abort",
+]

fable_v2/adapters.py

@@ -0,0 +1,151 @@
+"""Thin host adapters for portable Fable V2 integrations.
+
+The profiles describe a contract, not a claim that every host currently
+supports every capability.  An adapter should probe the host at startup and
+only advertise capabilities it can actually provide.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Iterable, Mapping, Any
+
+from .system3 import KripkeStructure, KripkeModelChecker, CausalDAG, CausalNode, CausalNodeType
+
+
+@dataclass(frozen=True)
+class HostCapabilities:
+    """Expected capabilities plus optional runtime-probed capabilities.
+
+    A profile is never authoritative until ``attest`` is called with the
+    result of a real host probe. This prevents documentation defaults from
+    silently becoming permission or compatibility claims.
+    """
+
+    host: str
+    capabilities: frozenset[str] = frozenset()
+    tool_aliases: Mapping[str, str] = field(default_factory=dict)
+    observed_capabilities: frozenset[str] | None = None
+    source: str = "expected-profile"
+
+    @property
+    def is_attested(self) -> bool:
+        return self.observed_capabilities is not None
+
+    def supports(self, capability: str, *, authoritative: bool = False) -> bool:
+        available = self.observed_capabilities if self.is_attested else self.capabilities
+        return capability in available and (not authoritative or self.is_attested)
+
+    def normalize(self, tool_name: str) -> str:
+        return self.tool_aliases.get(tool_name, tool_name)
+
+    def attest(self, observed: Iterable[str], source: str = "host-probe") -> "HostCapabilities":
+        """Return a runtime-authoritative profile from actual probe results."""
+        observed_set = frozenset(str(item).strip() for item in observed if str(item).strip())
+        return HostCapabilities(
+            host=self.host,
+            capabilities=self.capabilities,
+            tool_aliases=self.tool_aliases,
+            observed_capabilities=observed_set,
+            source=source,
+        )
+
+    def verify_temporal_capability_invariants(self, formula: str = "AG(capable)") -> dict[str, object]:
+        """Verify modal temporal logic invariant for host capabilities."""
+        kripke = KripkeStructure()
+        kripke.add_world("w_init", propositions={"initialized", "capable"} if self.is_attested else {"initialized"})
+        kripke.add_world("w_ready", propositions={"ready", "capable"} if self.is_attested else {"ready"})
+        kripke.add_transition("w_init", "w_ready")
+        kripke.add_transition("w_ready", "w_ready")
+        checker = KripkeModelChecker(kripke)
+        res = checker.check(formula, "w_init")
+        return {
+            "formula": formula,
+            "is_satisfied": res.is_satisfied,
+            "satisfying_worlds": sorted(list(res.satisfied_worlds)),
+        }
+
+    def validate_causal_capability_contract(self, target_capabilities: Iterable[str]) -> dict[str, object]:
+        """Validate causal DAG dependency flow for required capabilities."""
+        targets = list(target_capabilities)
+        available = self.observed_capabilities if self.is_attested else self.capabilities
+        missing = [c for c in targets if c not in available]
+        dag = CausalDAG(name=f"HostCapabilities_{self.host}")
+        for c in targets:
+            dag.add_node(
+                node_id=f"cap_{c}",
+                name=c,
+                node_type=CausalNodeType.EXOGENOUS if c in available else CausalNodeType.ENDOGENOUS,
+                value=1.0 if c in available else 0.0,
+            )
+        first_target = f"cap_{targets[0]}" if targets else None
+        if first_target and first_target in dag.nodes:
+            report = dag.evaluate_brittleness(target_metric=first_target)
+            b_score = report.overall_brittleness_score
+        else:
+            b_score = 0.0
+        return {
+            "is_valid": len(missing) == 0,
+            "missing": missing,
+            "brittleness_score": b_score,
+            "dag": dag.to_dict(),
+        }
+
+    def compatibility_report(self, required: Iterable[str]) -> dict[str, object]:
+        required_set = set(required)
+        expected = required_set & self.capabilities
+        available_set = self.observed_capabilities if self.is_attested else self.capabilities
+        available = required_set & available_set
+        missing = required_set - available_set
+        return {
+            "host": self.host,
+            "compatible": self.is_attested and not missing,
+            "authoritative": self.is_attested,
+            "capabilities_source": self.source,
+            "required": sorted(required_set),
+            "expected": sorted(expected),
+            "available": sorted(available),
+            "missing": sorted(missing),
+        }
+
+
+# These are conservative *expected* profiles. Real adapters must call
+# ``attest`` after probing the host; expected capabilities are never
+# runtime-authoritative.
+HOST_PROFILES: dict[str, HostCapabilities] = {
+    "antigravity": HostCapabilities(
+        "antigravity",
+        frozenset({"inspect_files", "search_web", "execute_command", "edit_files",
+                   "run_tests", "delegate_agents"}),
+        {"run_command": "execute_command", "write_to_file": "edit_files"},
+    ),
+    "claude-code": HostCapabilities(
+        "claude-code",
+        frozenset({"inspect_files", "execute_command", "edit_files", "run_tests"}),
+        {"shell": "execute_command"},
+    ),
+    "codex": HostCapabilities(
+        "codex",
+        frozenset({"inspect_files", "execute_command", "edit_files", "run_tests"}),
+        {"shell": "execute_command"},
+    ),
+    "cursor": HostCapabilities(
+        "cursor",
+        frozenset({"inspect_files", "execute_command", "edit_files", "run_tests"}),
+        {"terminal": "execute_command"},
+    ),
+    "grok-build": HostCapabilities("grok-build"),
+    "zapia": HostCapabilities(
+        "zapia",
+        frozenset({"inspect_files", "search_web", "execute_command", "run_tests",
+                   "delegate_agents"}),
+    ),
+}
+
+
+def get_profile(host: str) -> HostCapabilities:
+    """Return a conservative profile; unknown hosts start with no claims."""
+    key = host.strip().lower()
+    if not key:
+        raise ValueError("host must be a non-empty string")
+    return HOST_PROFILES.get(key, HostCapabilities(key))

fable_v2/coder_fleet/__init__.py

@@ -0,0 +1,100 @@
+"""10-Tool Coder Subagent MCP Fleet for Fable V2.
+
+Modular, pure-Python engines with zero mandatory external C-dependencies:
+- VisualGroundingEngine: Vector/SVG rendering validation, perceptual diffing, palette & bounding box extraction
+- DiagnosticsEngine: AST syntax & semantic diagnostics, automated quick fixes
+- TreeSitterCodemodEngine: AST structural queries, safe identifier renaming, syntax verification
+- AtomicWorkspaceEngine: File checkpointing, patch inspection, rollbacks, and SHA-256 milestone commits
+- TestHarnessEngine: Subprocess scratch test execution, timeout enforcement, concurrency fuzzing, memory profiling
+- MutationVerifierEngine: AST mutant injection, test suite kill rate auditing, fake test detection
+- MockAuditorEngine: Trivial assertion detection, tautology flagging, mock leakage detection, negative path auditing
+- PropertyOracleEngine: Extreme boundary matrix generation, algebraic roundtrip invariant verification
+- ReceiptAttestorEngine: Subprocess execution attestation, HMAC-SHA256 tamper-evident ToolReceipt generation and verification
+- ComputeOrchestratorEngine: Thinking token budget calculation, Monte Carlo Tree Search, Best-of-N consensus selection
+- CoderFleetDispatcher: Centralized router dispatching actions to all 10 engines
+"""
+from __future__ import annotations
+
+from .ast_tools import TreeSitterCodemodEngine
+from .compute import ComputeOrchestratorEngine
+from .design_engine import (
+    AestheticArchetype,
+    AntiSlopAuditor,
+    AwwwardsScaffoldGenerator,
+    BriefInferenceEngine,
+    DesignDials,
+    DesignEngine,
+    HauteDesignTheme,
+    OKLCHColorToken,
+    PreFlightDesignGate,
+    SlopViolation,
+    SpringPreset,
+    calculate_contrast_ratio,
+    generate_fluid_clamp,
+    HAUTE_THEMES,
+    SPRING_PRESETS,
+)
+from .diagnostics import DiagnosticsEngine
+from .fleet_dispatcher import CoderFleetDispatcher
+from .mock_auditor import MockAuditorEngine
+from .mutation import MutationVerifierEngine
+from .property_oracle import PropertyOracleEngine
+from .receipt_attestor import ReceiptAttestorEngine
+from .red_team_swarm import (
+    AttackVector,
+    BreakFinding,
+    BreakScenario,
+    RedTeamBreakageReport,
+    RedTeamSwarm,
+)
+from .test_harness import TestHarnessEngine
+from .vector_engine import (
+    BoundingBox,
+    FableVectorCompiler,
+    OKLCHColor,
+    ParametricGeometry,
+    VLayoutSolver,
+    VNode,
+)
+from .visual import VisualGroundingEngine
+from .workspace import AtomicWorkspaceEngine
+
+__all__ = [
+    "VisualGroundingEngine",
+    "DiagnosticsEngine",
+    "TreeSitterCodemodEngine",
+    "AtomicWorkspaceEngine",
+    "TestHarnessEngine",
+    "MutationVerifierEngine",
+    "MockAuditorEngine",
+    "PropertyOracleEngine",
+    "ReceiptAttestorEngine",
+    "ComputeOrchestratorEngine",
+    "CoderFleetDispatcher",
+    "AttackVector",
+    "BreakScenario",
+    "BreakFinding",
+    "RedTeamBreakageReport",
+    "RedTeamSwarm",
+    "OKLCHColor",
+    "ParametricGeometry",
+    "BoundingBox",
+    "VNode",
+    "VLayoutSolver",
+    "FableVectorCompiler",
+    "AestheticArchetype",
+    "AntiSlopAuditor",
+    "AwwwardsScaffoldGenerator",
+    "BriefInferenceEngine",
+    "DesignDials",
+    "DesignEngine",
+    "HauteDesignTheme",
+    "OKLCHColorToken",
+    "PreFlightDesignGate",
+    "SlopViolation",
+    "SpringPreset",
+    "calculate_contrast_ratio",
+    "generate_fluid_clamp",
+    "HAUTE_THEMES",
+    "SPRING_PRESETS",
+]