arkaos 2.0.0-alpha.1

package/core/conclave/profiler.py

@@ -0,0 +1,298 @@
+"""Conclave Profiler — Extract user behavioral DNA via structured questions.
+
+Uses targeted questions to determine the user's DISC, Enneagram, Big Five,
+and MBTI profiles. The profiler produces a UserProfile that the matcher
+uses to assemble a personalized Conclave board.
+
+Design: Each framework has 4-6 questions. Total profiling takes ~20 questions.
+Questions are multiple-choice to make scoring deterministic.
+"""
+
+from dataclasses import dataclass, field
+from core.agents.schema import (
+    BehavioralDNA, DISCProfile, DISCType,
+    EnneagramProfile, EnneagramType,
+    BigFiveProfile, MBTIProfile, MBTIType,
+)
+from core.conclave.schema import UserProfile
+
+
+@dataclass
+class ProfileQuestion:
+    """A single profiling question with scored options."""
+    id: str
+    framework: str           # disc, enneagram, big_five, mbti
+    question: str
+    options: list[dict]      # [{label, scores: {dimension: value}}]
+
+
+@dataclass
+class ProfilingSession:
+    """Tracks answers during a profiling session."""
+    answers: dict[str, str] = field(default_factory=dict)
+    scores: dict[str, float] = field(default_factory=dict)
+
+
+# --- DISC Questions (4 questions) ---
+
+DISC_QUESTIONS = [
+    ProfileQuestion(
+        id="disc-1", framework="disc",
+        question="When facing a new challenge at work, you tend to:",
+        options=[
+            {"label": "Take charge immediately and push for quick results", "scores": {"D": 3}},
+            {"label": "Rally the team with enthusiasm and brainstorm together", "scores": {"I": 3}},
+            {"label": "Carefully plan your approach before acting", "scores": {"C": 3}},
+            {"label": "Consider how it affects the team and build consensus", "scores": {"S": 3}},
+        ],
+    ),
+    ProfileQuestion(
+        id="disc-2", framework="disc",
+        question="In meetings, you are most likely to:",
+        options=[
+            {"label": "Drive the agenda and make decisions quickly", "scores": {"D": 3}},
+            {"label": "Energize the room with ideas and stories", "scores": {"I": 3}},
+            {"label": "Listen carefully and ensure everyone's input is heard", "scores": {"S": 3}},
+            {"label": "Focus on data, details, and logical analysis", "scores": {"C": 3}},
+        ],
+    ),
+    ProfileQuestion(
+        id="disc-3", framework="disc",
+        question="When someone disagrees with you, you typically:",
+        options=[
+            {"label": "State your position firmly and defend it with facts", "scores": {"D": 2, "C": 1}},
+            {"label": "Use persuasion and charm to bring them around", "scores": {"I": 2, "D": 1}},
+            {"label": "Seek compromise and try to maintain harmony", "scores": {"S": 2, "I": 1}},
+            {"label": "Analyze both sides objectively before responding", "scores": {"C": 2, "S": 1}},
+        ],
+    ),
+    ProfileQuestion(
+        id="disc-4", framework="disc",
+        question="Your biggest fear at work is:",
+        options=[
+            {"label": "Losing control or being taken advantage of", "scores": {"D": 3}},
+            {"label": "Being rejected or losing social approval", "scores": {"I": 3}},
+            {"label": "Sudden change or losing stability", "scores": {"S": 3}},
+            {"label": "Being wrong or producing low-quality work", "scores": {"C": 3}},
+        ],
+    ),
+]
+
+# --- Enneagram Questions (6 questions — triads first, then type) ---
+
+ENNEAGRAM_QUESTIONS = [
+    ProfileQuestion(
+        id="enn-1", framework="enneagram",
+        question="Which statement resonates most with you?",
+        options=[
+            {"label": "I need to be competent and knowledgeable", "scores": {"e5": 3, "e6": 1}},
+            {"label": "I need to be successful and admired", "scores": {"e3": 3, "e2": 1}},
+            {"label": "I need to be in control and strong", "scores": {"e8": 3, "e1": 1}},
+        ],
+    ),
+    ProfileQuestion(
+        id="enn-2", framework="enneagram",
+        question="Under stress, you tend to:",
+        options=[
+            {"label": "Withdraw and analyze the situation alone", "scores": {"e5": 3, "e4": 1}},
+            {"label": "Become more busy and action-oriented", "scores": {"e3": 2, "e7": 2}},
+            {"label": "Worry more and seek reassurance from trusted people", "scores": {"e6": 3}},
+            {"label": "Become more controlling or confrontational", "scores": {"e8": 2, "e1": 2}},
+        ],
+    ),
+    ProfileQuestion(
+        id="enn-3", framework="enneagram",
+        question="What drives your decisions most?",
+        options=[
+            {"label": "Doing what's right and maintaining high standards", "scores": {"e1": 3}},
+            {"label": "Helping others and building relationships", "scores": {"e2": 3}},
+            {"label": "Achieving goals and being the best", "scores": {"e3": 3}},
+            {"label": "Understanding deeply and mastering my domain", "scores": {"e5": 3}},
+        ],
+    ),
+    ProfileQuestion(
+        id="enn-4", framework="enneagram",
+        question="Which describes your inner world?",
+        options=[
+            {"label": "I seek freedom, variety, and new experiences", "scores": {"e7": 3}},
+            {"label": "I seek authenticity and deep self-expression", "scores": {"e4": 3}},
+            {"label": "I seek peace, harmony, and avoiding conflict", "scores": {"e9": 3}},
+            {"label": "I seek security, loyalty, and preparedness", "scores": {"e6": 3}},
+        ],
+    ),
+]
+
+# --- Big Five Questions (5 questions, one per trait) ---
+
+BIG_FIVE_QUESTIONS = [
+    ProfileQuestion(
+        id="bf-o", framework="big_five",
+        question="When it comes to new ideas and experiences:",
+        options=[
+            {"label": "I actively seek novel approaches and creative solutions", "scores": {"openness": 85}},
+            {"label": "I'm open to new things but prefer some familiarity", "scores": {"openness": 60}},
+            {"label": "I prefer proven methods and practical approaches", "scores": {"openness": 35}},
+        ],
+    ),
+    ProfileQuestion(
+        id="bf-c", framework="big_five",
+        question="How would you describe your work style?",
+        options=[
+            {"label": "Highly organized, disciplined, and detail-oriented", "scores": {"conscientiousness": 85}},
+            {"label": "Reasonably organized with some flexibility", "scores": {"conscientiousness": 60}},
+            {"label": "Spontaneous and adaptable, I figure things out as I go", "scores": {"conscientiousness": 35}},
+        ],
+    ),
+    ProfileQuestion(
+        id="bf-e", framework="big_five",
+        question="In social situations:",
+        options=[
+            {"label": "I'm energized by people and love being the center of conversation", "scores": {"extraversion": 85}},
+            {"label": "I enjoy socializing but also value alone time", "scores": {"extraversion": 55}},
+            {"label": "I prefer small groups or working alone, large groups drain me", "scores": {"extraversion": 25}},
+        ],
+    ),
+    ProfileQuestion(
+        id="bf-a", framework="big_five",
+        question="When making business decisions:",
+        options=[
+            {"label": "I prioritize people's feelings and building consensus", "scores": {"agreeableness": 80}},
+            {"label": "I balance people's needs with practical outcomes", "scores": {"agreeableness": 55}},
+            {"label": "I focus on results even if it means tough conversations", "scores": {"agreeableness": 30}},
+        ],
+    ),
+    ProfileQuestion(
+        id="bf-n", framework="big_five",
+        question="How do you handle pressure and setbacks?",
+        options=[
+            {"label": "I stay calm and composed, rarely rattled", "scores": {"neuroticism": 20}},
+            {"label": "I feel the pressure but manage it well", "scores": {"neuroticism": 45}},
+            {"label": "I feel things intensely and it takes time to rebalance", "scores": {"neuroticism": 75}},
+        ],
+    ),
+]
+
+# --- MBTI Questions (4 questions, one per dichotomy) ---
+
+MBTI_QUESTIONS = [
+    ProfileQuestion(
+        id="mbti-ei", framework="mbti",
+        question="You recharge your energy by:",
+        options=[
+            {"label": "Spending time with others, discussing ideas and socializing", "scores": {"E": 3}},
+            {"label": "Spending time alone, reflecting and processing internally", "scores": {"I": 3}},
+        ],
+    ),
+    ProfileQuestion(
+        id="mbti-sn", framework="mbti",
+        question="You prefer to focus on:",
+        options=[
+            {"label": "Concrete facts, details, and what's real right now", "scores": {"S": 3}},
+            {"label": "Patterns, possibilities, and what could be in the future", "scores": {"N": 3}},
+        ],
+    ),
+    ProfileQuestion(
+        id="mbti-tf", framework="mbti",
+        question="When making important decisions, you rely more on:",
+        options=[
+            {"label": "Logic, analysis, and objective criteria", "scores": {"T": 3}},
+            {"label": "Values, impact on people, and what feels right", "scores": {"F": 3}},
+        ],
+    ),
+    ProfileQuestion(
+        id="mbti-jp", framework="mbti",
+        question="You prefer your work environment to be:",
+        options=[
+            {"label": "Structured, planned, and decisive — I like closure", "scores": {"J": 3}},
+            {"label": "Flexible, open-ended, and adaptable — I like options", "scores": {"P": 3}},
+        ],
+    ),
+]
+
+
+def get_all_questions() -> list[ProfileQuestion]:
+    """Get all profiling questions in order."""
+    return DISC_QUESTIONS + ENNEAGRAM_QUESTIONS + BIG_FIVE_QUESTIONS + MBTI_QUESTIONS
+
+
+def score_disc(session: ProfilingSession) -> tuple[DISCType, DISCType]:
+    """Score DISC from session answers. Returns (primary, secondary)."""
+    totals = {"D": 0, "I": 0, "S": 0, "C": 0}
+    for key, val in session.scores.items():
+        if key in totals:
+            totals[key] += val
+    ranked = sorted(totals.items(), key=lambda x: x[1], reverse=True)
+    primary = DISCType(ranked[0][0])
+    secondary = DISCType(ranked[1][0]) if ranked[1][0] != ranked[0][0] else DISCType(ranked[2][0])
+    return primary, secondary
+
+
+def score_enneagram(session: ProfilingSession) -> tuple[int, int]:
+    """Score Enneagram from session. Returns (type, wing)."""
+    totals = {i: 0 for i in range(1, 10)}
+    for key, val in session.scores.items():
+        if key.startswith("e") and key[1:].isdigit():
+            totals[int(key[1:])] += val
+    ranked = sorted(totals.items(), key=lambda x: x[1], reverse=True)
+    enn_type = ranked[0][0]
+    # Wing must be adjacent
+    wing_a = enn_type - 1 if enn_type > 1 else 9
+    wing_b = enn_type + 1 if enn_type < 9 else 1
+    wing = wing_a if totals.get(wing_a, 0) >= totals.get(wing_b, 0) else wing_b
+    return enn_type, wing
+
+
+def score_big_five(session: ProfilingSession) -> BigFiveProfile:
+    """Score Big Five from session."""
+    return BigFiveProfile(
+        openness=int(session.scores.get("openness", 50)),
+        conscientiousness=int(session.scores.get("conscientiousness", 50)),
+        extraversion=int(session.scores.get("extraversion", 50)),
+        agreeableness=int(session.scores.get("agreeableness", 50)),
+        neuroticism=int(session.scores.get("neuroticism", 50)),
+    )
+
+
+def score_mbti(session: ProfilingSession) -> MBTIType:
+    """Score MBTI from session."""
+    ei = "E" if session.scores.get("E", 0) >= session.scores.get("I", 0) else "I"
+    sn = "S" if session.scores.get("S", 0) >= session.scores.get("N", 0) else "N"
+    tf = "T" if session.scores.get("T", 0) >= session.scores.get("F", 0) else "F"
+    jp = "J" if session.scores.get("J", 0) >= session.scores.get("P", 0) else "P"
+    return MBTIType(f"{ei}{sn}{tf}{jp}")
+
+
+def process_answer(session: ProfilingSession, question: ProfileQuestion, option_index: int) -> None:
+    """Process a single answer and accumulate scores."""
+    if 0 <= option_index < len(question.options):
+        option = question.options[option_index]
+        session.answers[question.id] = option["label"]
+        for dimension, value in option.get("scores", {}).items():
+            session.scores[dimension] = session.scores.get(dimension, 0) + value
+
+
+def build_profile_from_session(
+    session: ProfilingSession,
+    name: str = "",
+    company: str = "",
+    role: str = "",
+) -> UserProfile:
+    """Build a complete UserProfile from a scoring session."""
+    disc_primary, disc_secondary = score_disc(session)
+    enn_type, enn_wing = score_enneagram(session)
+    big_five = score_big_five(session)
+    mbti_type = score_mbti(session)
+
+    dna = BehavioralDNA(
+        disc=DISCProfile(primary=disc_primary, secondary=disc_secondary),
+        enneagram=EnneagramProfile(type=EnneagramType(enn_type), wing=enn_wing),
+        big_five=big_five,
+        mbti=MBTIProfile(type=mbti_type),
+    )
+
+    return UserProfile(
+        name=name,
+        company=company,
+        role=role,
+        behavioral_dna=dna,
+    )

package/core/conclave/prompts.py

@@ -0,0 +1,77 @@
+"""Conclave prompts — system prompts that make advisors respond in character."""
+
+from core.conclave.schema import Advisor
+
+
+def build_advisor_prompt(advisor: Advisor, question: str) -> str:
+    """Build a system prompt that makes an AI respond as this advisor.
+
+    The prompt channels the advisor's thinking style, mental models,
+    and communication patterns.
+    """
+    models_text = "\n".join(
+        f"- {m.name}: {m.question}" for m in advisor.mental_models
+    )
+    questions_text = "\n".join(f'- "{q}"' for q in advisor.key_questions)
+
+    return f"""You are {advisor.name}, {advisor.title}.
+
+Your mental models:
+{models_text}
+
+Your key questions:
+{questions_text}
+
+Communication style: {advisor.communication_style}
+Decision framework: {advisor.decision_framework}
+
+Respond to the following question as {advisor.name} would. Use your mental models.
+Be specific to THIS situation, not generic. 3-5 sentences maximum.
+Channel {advisor.name}'s actual thinking and vocabulary.
+
+Question: {question}"""
+
+
+def build_debate_prompt(advisors: list[Advisor], topic: str) -> str:
+    """Build a prompt for an advisor debate on a topic."""
+    advisor_list = "\n".join(
+        f"- {a.name} ({a.title}): {a.communication_style}" for a in advisors
+    )
+
+    return f"""You are moderating a debate between these advisors:
+
+{advisor_list}
+
+Topic: {topic}
+
+For EACH advisor, write 2-3 sentences from their perspective using their known
+mental models and communication style. Then identify:
+1. Where the aligned advisors agree
+2. Where the contrarian advisors push back
+3. The key tension the user should consider
+
+Keep each advisor's voice distinct and authentic."""
+
+
+def build_ask_all_prompt(advisors: list[Advisor], question: str) -> str:
+    """Build a prompt that channels all advisors responding to one question."""
+    sections = []
+
+    for advisor in advisors:
+        models = ", ".join(m.name for m in advisor.mental_models[:2])
+        sections.append(
+            f"**{advisor.name}** ({advisor.advisor_type.value}) — "
+            f"Uses: {models}. Style: {advisor.communication_style}"
+        )
+
+    advisor_context = "\n".join(sections)
+
+    return f"""The user asked their Conclave advisory board: "{question}"
+
+Advisors on the board:
+{advisor_context}
+
+For each advisor, write a 2-3 sentence response that channels their specific
+thinking style and mental models. Use their actual vocabulary and frameworks.
+Make each response distinct. End with a brief synthesis of where they agree
+and where they diverge."""

package/core/conclave/schema.py

@@ -0,0 +1,132 @@
+"""Conclave schema — User profiles, advisors, and the board.
+
+The Conclave creates a personalized advisory board by:
+1. Profiling the user's behavioral DNA (DISC + Enneagram + Big5 + MBTI)
+2. Matching 5 aligned advisors (same cognitive profile)
+3. Matching 5 contrarian advisors (opposite profile)
+"""
+
+from enum import Enum
+from typing import Optional
+from pydantic import BaseModel, Field
+
+from core.agents.schema import (
+    DISCProfile, DISCType,
+    EnneagramProfile, EnneagramType,
+    BigFiveProfile,
+    MBTIProfile, MBTIType,
+    BehavioralDNA,
+)
+
+
+class AdvisorType(str, Enum):
+    ALIGNED = "aligned"
+    CONTRARIAN = "contrarian"
+
+
+class MentalModel(BaseModel):
+    """A codified mental model used by an advisor."""
+    name: str
+    description: str = ""
+    question: str = ""  # The key question this model asks
+    example: str = ""   # Example of applying this model
+
+
+class Advisor(BaseModel):
+    """A real-world person serving as an AI advisor.
+
+    Each advisor has a behavioral DNA profile, mental models,
+    and a specific communication style based on the real person.
+    """
+    id: str
+    name: str
+    title: str = ""                      # e.g., "Investor, Berkshire Hathaway"
+    why_selected: str = ""               # Why this advisor was matched
+    advisor_type: AdvisorType = AdvisorType.ALIGNED
+
+    behavioral_dna: BehavioralDNA
+    mental_models: list[MentalModel] = Field(default_factory=list)
+
+    key_questions: list[str] = Field(default_factory=list)
+    communication_style: str = ""
+    decision_framework: str = ""
+    sources: list[str] = Field(default_factory=list)  # Books, talks, etc.
+
+    def match_score_to(self, user_dna: BehavioralDNA) -> float:
+        """Calculate how well this advisor's DNA matches a user's DNA.
+
+        Higher score = more similar (for aligned advisors).
+        Lower score = more different (for contrarian advisors).
+        """
+        score = 0.0
+        total = 4.0
+
+        # DISC match (same primary = +1)
+        if self.behavioral_dna.disc.primary == user_dna.disc.primary:
+            score += 1.0
+        elif self.behavioral_dna.disc.secondary == user_dna.disc.primary:
+            score += 0.5
+
+        # Enneagram match (same center = +1, same type = +1)
+        if self.behavioral_dna.enneagram.center == user_dna.enneagram.center:
+            score += 0.5
+        if self.behavioral_dna.enneagram.type == user_dna.enneagram.type:
+            score += 0.5
+
+        # Big Five match (average distance, inverted)
+        user_bf = user_dna.big_five
+        adv_bf = self.behavioral_dna.big_five
+        diffs = [
+            abs(user_bf.openness - adv_bf.openness),
+            abs(user_bf.conscientiousness - adv_bf.conscientiousness),
+            abs(user_bf.extraversion - adv_bf.extraversion),
+            abs(user_bf.agreeableness - adv_bf.agreeableness),
+            abs(user_bf.neuroticism - adv_bf.neuroticism),
+        ]
+        avg_diff = sum(diffs) / len(diffs)
+        score += 1.0 - (avg_diff / 100.0)
+
+        # MBTI match (same dominant function = +1)
+        if self.behavioral_dna.mbti.dominant == user_dna.mbti.dominant:
+            score += 1.0
+        elif self.behavioral_dna.mbti.auxiliary == user_dna.mbti.dominant:
+            score += 0.5
+
+        return round(score / total, 2)
+
+
+class UserProfile(BaseModel):
+    """The user's behavioral DNA profile for Conclave matching."""
+    name: str = ""
+    company: str = ""
+    role: str = ""
+    behavioral_dna: BehavioralDNA
+    objectives: list[str] = Field(default_factory=list)
+    industries: list[str] = Field(default_factory=list)
+
+
+class ConclaveBoard(BaseModel):
+    """The complete Conclave board: 5 aligned + 5 contrarian advisors."""
+    user: UserProfile
+    aligned: list[Advisor] = Field(default_factory=list, max_length=5)
+    contrarian: list[Advisor] = Field(default_factory=list, max_length=5)
+
+    @property
+    def all_advisors(self) -> list[Advisor]:
+        return self.aligned + self.contrarian
+
+    @property
+    def size(self) -> int:
+        return len(self.aligned) + len(self.contrarian)
+
+    def get_advisor(self, advisor_id: str) -> Optional[Advisor]:
+        for a in self.all_advisors:
+            if a.id == advisor_id:
+                return a
+        return None
+
+    def advisor_names(self) -> dict[str, list[str]]:
+        return {
+            "aligned": [a.name for a in self.aligned],
+            "contrarian": [a.name for a in self.contrarian],
+        }

package/core/governance/__init__.py

@@ -0,0 +1,5 @@
+"""Governance engine — Constitution, quality gates, audit trails."""
+
+from core.governance.constitution import Constitution, load_constitution
+
+__all__ = ["Constitution", "load_constitution"]

package/core/governance/constitution.py

@@ -0,0 +1,152 @@
+"""Constitution schema and loader.
+
+The Constitution defines governance rules at 4 enforcement levels:
+- NON-NEGOTIABLE: Violations abort operations
+- QUALITY_GATE: Mandatory pre-delivery review
+- MUST: Mandatory, violations logged
+- SHOULD: Best practices, encouraged
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class Rule(BaseModel):
+    """A single governance rule."""
+    id: str
+    rule: str
+    enforcement: str = ""
+    pattern: str = ""
+    metric: str = ""
+
+
+class QualityAgent(BaseModel):
+    """A quality gate agent."""
+    id: str
+    role: str = ""
+    scope: str = ""
+    authority: str = ""
+    veto_power: bool = False
+
+
+class QualityGateConfig(BaseModel):
+    """Quality Gate configuration."""
+    description: str = ""
+    agents: dict = Field(default_factory=dict)
+    process: list[str] = Field(default_factory=list)
+
+
+class EnforcementLevel(BaseModel):
+    """A group of rules at the same enforcement level."""
+    description: str = ""
+    rules: list[Rule] = Field(default_factory=list)
+
+
+class TierConfig(BaseModel):
+    """Configuration for an agent tier."""
+    name: str
+    description: str = ""
+    max_agents: int = 0
+    authorities: list[str] = Field(default_factory=list)
+
+
+class ConflictRule(BaseModel):
+    """A conflict resolution pattern."""
+    pattern: str
+    resolution: str
+
+
+class ConflictResolution(BaseModel):
+    """Conflict resolution rules."""
+    description: str = ""
+    rules: list[ConflictRule] = Field(default_factory=list)
+    escalation: dict[str, str] = Field(default_factory=dict)
+
+
+class Constitution(BaseModel):
+    """The ArkaOS Constitution — governance for the entire system."""
+    version: str
+    name: str
+    description: str = ""
+
+    enforcement_levels: dict = Field(default_factory=dict)
+    tier_hierarchy: dict = Field(default_factory=dict)
+    conflict_resolution: ConflictResolution = Field(default_factory=ConflictResolution)
+    amendments: dict = Field(default_factory=dict)
+
+    def get_non_negotiable_rules(self) -> list[Rule]:
+        """Get all NON-NEGOTIABLE rules."""
+        nn = self.enforcement_levels.get("non_negotiable", {})
+        raw_rules = nn.get("rules", [])
+        return [Rule.model_validate(r) for r in raw_rules]
+
+    def get_must_rules(self) -> list[Rule]:
+        """Get all MUST rules."""
+        must = self.enforcement_levels.get("must", {})
+        raw_rules = must.get("rules", [])
+        return [Rule.model_validate(r) for r in raw_rules]
+
+    def get_should_rules(self) -> list[Rule]:
+        """Get all SHOULD rules."""
+        should = self.enforcement_levels.get("should", {})
+        raw_rules = should.get("rules", [])
+        return [Rule.model_validate(r) for r in raw_rules]
+
+    def get_rule_ids(self) -> list[str]:
+        """Get all rule IDs across all enforcement levels."""
+        ids = []
+        for rules in [self.get_non_negotiable_rules(), self.get_must_rules(), self.get_should_rules()]:
+            ids.extend(r.id for r in rules)
+        return ids
+
+    def is_rule_non_negotiable(self, rule_id: str) -> bool:
+        """Check if a rule is NON-NEGOTIABLE."""
+        return rule_id in [r.id for r in self.get_non_negotiable_rules()]
+
+    def compress_for_context(self) -> str:
+        """Compress Constitution to a compact string for context injection.
+
+        This creates the L0 context layer that Synapse injects into every prompt.
+        """
+        nn_ids = [r.id for r in self.get_non_negotiable_rules()]
+        must_ids = [r.id for r in self.get_must_rules()]
+
+        qg = self.enforcement_levels.get("quality_gate", {})
+        qg_agents = qg.get("agents", {})
+        orchestrator = qg_agents.get("orchestrator", {})
+        reviewers = qg_agents.get("reviewers", [])
+
+        qg_parts = []
+        if orchestrator:
+            qg_parts.append(orchestrator.get("id", ""))
+        for r in reviewers:
+            qg_parts.append(r.get("id", ""))
+
+        parts = [
+            f"[Constitution] NON-NEGOTIABLE: {', '.join(nn_ids)}",
+            f"QUALITY-GATE: {', '.join(qg_parts)}",
+            f"MUST: {', '.join(must_ids)}",
+        ]
+        return " | ".join(parts)
+
+
+def load_constitution(path: str | Path) -> Constitution:
+    """Load Constitution from YAML file.
+
+    Args:
+        path: Path to constitution.yaml
+
+    Returns:
+        Validated Constitution instance.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Constitution file not found: {path}")
+
+    with open(path) as f:
+        data = yaml.safe_load(f)
+
+    return Constitution.model_validate(data)

package/core/registry/__init__.py

@@ -0,0 +1 @@
+"""Command registry — auto-generated from SKILL.md files."""