arkaos 2.0.0-alpha.1

package/core/agents/schema.py

@@ -0,0 +1,265 @@
+"""Agent schema — Pydantic models for the 4-framework behavioral DNA.
+
+Every ArkaOS agent has a complete behavioral profile composed of:
+- DISC: How they act (observable behavior)
+- Enneagram: Why they act (core motivation)
+- Big Five/OCEAN: How much of each trait (continuous 0-100)
+- MBTI: How they process information (cognitive functions)
+"""
+
+from enum import Enum
+from typing import Optional
+from pydantic import BaseModel, Field, model_validator
+
+
+# --- DISC Framework ---
+
+class DISCType(str, Enum):
+    D = "D"  # Dominance
+    I = "I"  # Influence
+    S = "S"  # Steadiness
+    C = "C"  # Conscientiousness
+
+
+class DISCProfile(BaseModel):
+    """DISC behavioral profile — how the agent acts."""
+    primary: DISCType
+    secondary: DISCType
+    label: str = ""
+    communication_style: str = ""
+    under_pressure: str = ""
+    motivator: str = ""
+
+    @model_validator(mode="after")
+    def primary_differs_from_secondary(self) -> "DISCProfile":
+        if self.primary == self.secondary:
+            raise ValueError("DISC primary and secondary must be different")
+        if not self.label:
+            labels = {"D": "Driver", "I": "Inspirer", "S": "Supporter", "C": "Analyst"}
+            self.label = f"{labels[self.primary.value]}-{labels[self.secondary.value]}"
+        return self
+
+
+# --- Enneagram Framework ---
+
+class EnneagramType(int, Enum):
+    REFORMER = 1
+    HELPER = 2
+    ACHIEVER = 3
+    INDIVIDUALIST = 4
+    INVESTIGATOR = 5
+    LOYALIST = 6
+    ENTHUSIAST = 7
+    CHALLENGER = 8
+    PEACEMAKER = 9
+
+
+class EnneagramCenter(str, Enum):
+    BODY = "body"      # 8, 9, 1 — Anger/Instinct
+    HEART = "heart"    # 2, 3, 4 — Shame/Feeling
+    HEAD = "head"      # 5, 6, 7 — Fear/Thinking
+
+
+class InstinctualSubtype(str, Enum):
+    SP = "self-preservation"
+    SO = "social"
+    SX = "sexual"
+
+
+ENNEAGRAM_CENTERS = {
+    1: EnneagramCenter.BODY, 2: EnneagramCenter.HEART, 3: EnneagramCenter.HEART,
+    4: EnneagramCenter.HEART, 5: EnneagramCenter.HEAD, 6: EnneagramCenter.HEAD,
+    7: EnneagramCenter.HEAD, 8: EnneagramCenter.BODY, 9: EnneagramCenter.BODY,
+}
+
+ENNEAGRAM_NAMES = {
+    1: "The Reformer", 2: "The Helper", 3: "The Achiever",
+    4: "The Individualist", 5: "The Investigator", 6: "The Loyalist",
+    7: "The Enthusiast", 8: "The Challenger", 9: "The Peacemaker",
+}
+
+# Growth and stress arrows
+ENNEAGRAM_GROWTH = {1: 7, 2: 4, 3: 6, 4: 1, 5: 8, 6: 9, 7: 5, 8: 2, 9: 3}
+ENNEAGRAM_STRESS = {1: 4, 2: 8, 3: 9, 4: 2, 5: 7, 6: 3, 7: 1, 8: 5, 9: 6}
+
+
+class EnneagramProfile(BaseModel):
+    """Enneagram motivational profile — why the agent acts."""
+    type: EnneagramType
+    wing: int = Field(ge=1, le=9)
+    label: str = ""
+    core_motivation: str = ""
+    core_fear: str = ""
+    center: EnneagramCenter = EnneagramCenter.HEAD
+    growth_arrow: int = Field(default=0, ge=0, le=9)
+    stress_arrow: int = Field(default=0, ge=0, le=9)
+    subtype: InstinctualSubtype = InstinctualSubtype.SP
+
+    @model_validator(mode="after")
+    def validate_wing_and_arrows(self) -> "EnneagramProfile":
+        t = self.type.value
+        # Wing must be adjacent
+        valid_wings = {t - 1 if t > 1 else 9, t + 1 if t < 9 else 1}
+        if self.wing not in valid_wings:
+            raise ValueError(f"Enneagram {t} wing must be {valid_wings}, got {self.wing}")
+        # Auto-fill center and arrows
+        self.center = ENNEAGRAM_CENTERS[t]
+        if self.growth_arrow == 0:
+            self.growth_arrow = ENNEAGRAM_GROWTH[t]
+        if self.stress_arrow == 0:
+            self.stress_arrow = ENNEAGRAM_STRESS[t]
+        if not self.label:
+            self.label = f"{t}w{self.wing} — {ENNEAGRAM_NAMES[t]}"
+        return self
+
+
+# --- Big Five / OCEAN Framework ---
+
+class BigFiveProfile(BaseModel):
+    """Big Five personality traits — continuous scale 0-100."""
+    openness: int = Field(ge=0, le=100, description="Creativity, curiosity")
+    conscientiousness: int = Field(ge=0, le=100, description="Organization, discipline")
+    extraversion: int = Field(ge=0, le=100, description="Energy, sociability")
+    agreeableness: int = Field(ge=0, le=100, description="Cooperation, empathy")
+    neuroticism: int = Field(ge=0, le=100, description="Emotional reactivity")
+
+
+# --- MBTI Framework ---
+
+class MBTIType(str, Enum):
+    INTJ = "INTJ"; INTP = "INTP"; ENTJ = "ENTJ"; ENTP = "ENTP"
+    INFJ = "INFJ"; INFP = "INFP"; ENFJ = "ENFJ"; ENFP = "ENFP"
+    ISTJ = "ISTJ"; ISFJ = "ISFJ"; ESTJ = "ESTJ"; ESFJ = "ESFJ"
+    ISTP = "ISTP"; ISFP = "ISFP"; ESTP = "ESTP"; ESFP = "ESFP"
+
+
+class CognitiveFunction(str, Enum):
+    Ni = "Ni"  # Introverted Intuition
+    Ne = "Ne"  # Extraverted Intuition
+    Si = "Si"  # Introverted Sensing
+    Se = "Se"  # Extraverted Sensing
+    Ti = "Ti"  # Introverted Thinking
+    Te = "Te"  # Extraverted Thinking
+    Fi = "Fi"  # Introverted Feeling
+    Fe = "Fe"  # Extraverted Feeling
+
+
+# Cognitive function stacks per MBTI type
+MBTI_STACKS: dict[str, list[str]] = {
+    "INTJ": ["Ni", "Te", "Fi", "Se"], "INTP": ["Ti", "Ne", "Si", "Fe"],
+    "ENTJ": ["Te", "Ni", "Se", "Fi"], "ENTP": ["Ne", "Ti", "Fe", "Si"],
+    "INFJ": ["Ni", "Fe", "Ti", "Se"], "INFP": ["Fi", "Ne", "Si", "Te"],
+    "ENFJ": ["Fe", "Ni", "Se", "Ti"], "ENFP": ["Ne", "Fi", "Te", "Si"],
+    "ISTJ": ["Si", "Te", "Fi", "Ne"], "ISFJ": ["Si", "Fe", "Ti", "Ne"],
+    "ESTJ": ["Te", "Si", "Ne", "Fi"], "ESFJ": ["Fe", "Si", "Ne", "Ti"],
+    "ISTP": ["Ti", "Se", "Ni", "Fe"], "ISFP": ["Fi", "Se", "Ni", "Te"],
+    "ESTP": ["Se", "Ti", "Fe", "Ni"], "ESFP": ["Se", "Fi", "Te", "Ni"],
+}
+
+
+class MBTIProfile(BaseModel):
+    """MBTI cognitive profile — how the agent processes information."""
+    type: MBTIType
+    dominant: CognitiveFunction = CognitiveFunction.Ni
+    auxiliary: CognitiveFunction = CognitiveFunction.Te
+    tertiary: CognitiveFunction = CognitiveFunction.Fi
+    inferior: CognitiveFunction = CognitiveFunction.Se
+
+    @model_validator(mode="after")
+    def auto_fill_stack(self) -> "MBTIProfile":
+        stack = MBTI_STACKS[self.type.value]
+        self.dominant = CognitiveFunction(stack[0])
+        self.auxiliary = CognitiveFunction(stack[1])
+        self.tertiary = CognitiveFunction(stack[2])
+        self.inferior = CognitiveFunction(stack[3])
+        return self
+
+
+# --- Behavioral DNA (All 4 Frameworks Combined) ---
+
+class BehavioralDNA(BaseModel):
+    """Complete behavioral DNA — 4 frameworks combined."""
+    disc: DISCProfile
+    enneagram: EnneagramProfile
+    big_five: BigFiveProfile
+    mbti: MBTIProfile
+
+
+# --- Mental Models ---
+
+class MentalModels(BaseModel):
+    """Mental models the agent uses for decision-making."""
+    primary: list[str] = Field(default_factory=list, max_length=5)
+    secondary: list[str] = Field(default_factory=list, max_length=5)
+
+
+# --- Authority Matrix ---
+
+class Authority(BaseModel):
+    """What the agent is authorized to do."""
+    veto: bool = False
+    push_code: bool = False
+    deploy: bool = False
+    approve_architecture: bool = False
+    approve_quality: bool = False
+    approve_budget: bool = False
+    block_release: bool = False
+    block_delivery: bool = False
+    orchestrate: bool = False
+    delegates_to: list[str] = Field(default_factory=list)
+    escalates_to: Optional[str] = None
+
+
+# --- Communication Style ---
+
+class Communication(BaseModel):
+    """How the agent communicates."""
+    language: str = "en"
+    tone: str = "professional"
+    vocabulary_level: str = "advanced"  # basic, intermediate, advanced, specialist
+    preferred_format: str = "structured"
+    avoid: list[str] = Field(default_factory=list)
+
+
+# --- Expertise ---
+
+class Expertise(BaseModel):
+    """What the agent knows."""
+    domains: list[str] = Field(default_factory=list)
+    frameworks: list[str] = Field(default_factory=list)
+    depth: str = "expert"  # novice, intermediate, expert, master
+    years_equivalent: int = 10
+
+
+# --- The Complete Agent ---
+
+class Agent(BaseModel):
+    """Complete ArkaOS v2 agent definition.
+
+    Every agent has:
+    - Identity: id, name, role, department, tier
+    - Behavioral DNA: DISC + Enneagram + Big Five + MBTI
+    - Mental Models: primary + secondary decision frameworks
+    - Authority: what they can approve, veto, or delegate
+    - Expertise: domains, frameworks, depth
+    - Communication: tone, format, language
+    """
+    id: str
+    name: str
+    role: str
+    department: str
+    tier: int = Field(ge=0, le=3)
+
+    behavioral_dna: BehavioralDNA
+    mental_models: MentalModels = Field(default_factory=MentalModels)
+    authority: Authority = Field(default_factory=Authority)
+    expertise: Expertise = Field(default_factory=Expertise)
+    communication: Communication = Field(default_factory=Communication)
+
+    memory_path: str = ""
+
+    @model_validator(mode="after")
+    def auto_fill_memory_path(self) -> "Agent":
+        if not self.memory_path:
+            self.memory_path = f"~/.claude/agent-memory/arka-{self.id}/MEMORY.md"
+        return self

package/core/agents/validator.py

@@ -0,0 +1,141 @@
+"""Cross-framework consistency validation for agent behavioral DNA.
+
+Not all combinations make sense. A DISC "S" (calm, steady) with Enneagram 8
+(challenger, aggressive) would be incoherent. This module validates that
+the 4 frameworks form a consistent personality.
+"""
+
+from dataclasses import dataclass, field
+from core.agents.schema import Agent, DISCType
+
+
+@dataclass
+class ValidationResult:
+    """Result of agent consistency validation."""
+    is_valid: bool
+    score: float  # 0.0 to 1.0
+    warnings: list[str] = field(default_factory=list)
+    errors: list[str] = field(default_factory=list)
+
+
+# Compatible Enneagram types per DISC primary
+DISC_ENNEAGRAM_COMPAT: dict[str, set[int]] = {
+    "D": {1, 3, 7, 8},
+    "I": {2, 3, 7, 9},
+    "S": {2, 6, 9},
+    "C": {1, 5, 6},
+}
+
+# Compatible MBTI types per DISC primary
+DISC_MBTI_COMPAT: dict[str, set[str]] = {
+    "D": {"ENTJ", "ESTJ", "INTJ", "ESTP", "ENTP"},
+    "I": {"ENFP", "ESFP", "ENFJ", "ENTP", "ESFJ"},
+    "S": {"ISFJ", "INFP", "ESFJ", "ISFP", "INFJ"},
+    "C": {"INTJ", "ISTJ", "INTP", "ISTP", "INFJ"},
+}
+
+# Big Five expectations per DISC primary (range: low/mid/high)
+DISC_BIG5_EXPECTATIONS: dict[str, dict[str, str]] = {
+    "D": {"extraversion": "mid-high", "agreeableness": "low-mid", "conscientiousness": "mid-high"},
+    "I": {"extraversion": "high", "agreeableness": "mid-high", "openness": "mid-high"},
+    "S": {"agreeableness": "high", "neuroticism": "low-mid", "extraversion": "low-mid"},
+    "C": {"conscientiousness": "high", "openness": "mid-high", "neuroticism": "low-mid"},
+}
+
+
+def _check_range(value: int, expected: str) -> bool:
+    """Check if a Big Five value falls within expected range."""
+    ranges = {
+        "low": (0, 35),
+        "low-mid": (0, 55),
+        "mid": (30, 70),
+        "mid-high": (45, 100),
+        "high": (65, 100),
+    }
+    lo, hi = ranges[expected]
+    return lo <= value <= hi
+
+
+def validate_agent_consistency(agent: Agent) -> ValidationResult:
+    """Validate cross-framework consistency of an agent's behavioral DNA.
+
+    Checks:
+    1. DISC primary ↔ Enneagram type compatibility
+    2. DISC primary ↔ MBTI type compatibility
+    3. DISC primary ↔ Big Five expectations
+    4. Tier ↔ Authority consistency
+    """
+    warnings: list[str] = []
+    errors: list[str] = []
+    checks_passed = 0
+    total_checks = 0
+
+    dna = agent.behavioral_dna
+    disc_primary = dna.disc.primary.value
+
+    # Check 1: DISC ↔ Enneagram
+    total_checks += 1
+    compat_enneagram = DISC_ENNEAGRAM_COMPAT.get(disc_primary, set())
+    if dna.enneagram.type.value in compat_enneagram:
+        checks_passed += 1
+    else:
+        warnings.append(
+            f"DISC {disc_primary} with Enneagram {dna.enneagram.type.value} is unusual. "
+            f"Expected: {compat_enneagram}. This may be intentional for a unique personality."
+        )
+
+    # Check 2: DISC ↔ MBTI
+    total_checks += 1
+    compat_mbti = DISC_MBTI_COMPAT.get(disc_primary, set())
+    if dna.mbti.type.value in compat_mbti:
+        checks_passed += 1
+    else:
+        warnings.append(
+            f"DISC {disc_primary} with MBTI {dna.mbti.type.value} is unusual. "
+            f"Expected: {compat_mbti}."
+        )
+
+    # Check 3: DISC ↔ Big Five
+    expectations = DISC_BIG5_EXPECTATIONS.get(disc_primary, {})
+    for trait, expected_range in expectations.items():
+        total_checks += 1
+        value = getattr(dna.big_five, trait)
+        if _check_range(value, expected_range):
+            checks_passed += 1
+        else:
+            warnings.append(
+                f"DISC {disc_primary} expects Big Five {trait} in {expected_range} range, "
+                f"got {value}. This creates tension in the personality."
+            )
+
+    # Check 4: Tier ↔ Authority
+    total_checks += 1
+    if agent.tier == 0:
+        if not agent.authority.veto:
+            warnings.append("Tier 0 agents typically have veto power.")
+        else:
+            checks_passed += 1
+    elif agent.tier >= 2:
+        if agent.authority.veto:
+            errors.append("Tier 2+ agents should not have veto power.")
+        else:
+            checks_passed += 1
+    else:
+        checks_passed += 1
+
+    # Check 5: Tier 0 should have escalates_to = None
+    total_checks += 1
+    if agent.tier == 0 and agent.authority.escalates_to is not None:
+        warnings.append("Tier 0 agents are top-level and typically don't escalate.")
+    else:
+        checks_passed += 1
+
+    score = checks_passed / total_checks if total_checks > 0 else 0.0
+    is_valid = len(errors) == 0
+
+    return ValidationResult(
+        is_valid=is_valid,
+        score=round(score, 2),
+        warnings=warnings,
+        errors=errors,
+    )

package/core/conclave/__init__.py

@@ -0,0 +1,12 @@
+"""The Conclave — Personal AI Advisory Board.
+
+10 AI advisors personalized to the user's behavioral DNA:
+- 5 Aligned: think like the user (amplify strengths)
+- 5 Contrarian: opposite of the user (challenge biases)
+Each advisor based on a real person with codified mental models.
+"""
+
+from core.conclave.schema import UserProfile, Advisor, ConclaveBoard
+from core.conclave.matcher import match_advisors
+
+__all__ = ["UserProfile", "Advisor", "ConclaveBoard", "match_advisors"]