class HierarchicalStore:
    """
    层级化记忆存储。
    祖先 Store 对后代只读——后代可以继承，但不能篡改。
    """
    def __init__(self, data=None, parent=None, readonly=False):
        self._data = data or {}
        self._parent = parent
        self._readonly = readonly  # 关键：只读标记

    def save(self, key, value):
        if self._readonly:
            raise PermissionError("只读 Store 禁止写入")
        self._data[key] = value

    def load(self, key, default=None):
        if key in self._data:
            return self._data[key]
        if self._parent:
            return self._parent.load(key, default)
        return default

def validate_sop(ancestor_sop, descendant_sop):
    """
    祖辈验证后代的 SOP 是否合规。
    检查点：
    1. 后代 SOP 的步骤不能超出祖辈定义的边界
    2. 后代 SOP 不能调用未授权的 Skill
    3. 后代 SOP 的数据访问不能超出权限范围
    """
    # 检查 1：步骤边界
    for step in descendant_sop.steps:
        if step not in ancestor_sop.allowed_steps:
            raise SOPValidationError(
                f"步骤 {step} 超出祖辈定义的边界"
            )

    # 检查 2：Skill 授权
    for skill in descendant_sop.required_skills:
        if skill not in ancestor_sop.authorized_skills:
            raise SOPValidationError(
                f"Skill {skill} 未获授权"
            )

    return True

class Agent:
    def __init__(self, name, store, skills, generation=0, max_spawn_generation=3):
        self.name = name
        self.generation = generation
        self.max_spawn_generation = max_spawn_generation  # 最大代数限制

    def spawn_child(self, child_name, child_skills):
        if self.generation >= self.max_spawn_generation:
            raise GenerationError(
                f"Agent {self.name} (第{self.generation}代) "
                f"已达到最大生成代数限制({self.max_spawn_generation})"
            )
        # 创建子 Agent，代数 +1
        return Agent(
            name=child_name,
            store=HierarchicalStore(parent=self.store, readonly=True),
            skills=child_skills,
            generation=self.generation + 1,
            max_spawn_generation=self.max_spawn_generation
        )

def merge_from(parent_store, child_output):
    """
    父辈从子 Agent 的输出中选择性地保留有价值的内容。
    这是一个显式的、可审计的决策过程。
    """
    for key, value in child_output.items():
        if parent_store.approves(key, value):  # 显式审核
            parent_store.save(key, value)
        else:
            log_discard(key, value)  # 记录丢弃决策

from core import Store, Agent, SOP
from core.governance import HierarchicalStore, validate_sop

# 第一步：定义祖辈宪法
constitution = {
    "data_boundary": ["customer_info", "product_catalog"],
    "authorized_skills": ["search_product", "generate_reply", "escalate"],
    "max_generation": 3
}

# 第二步：创建祖辈 Agent
ancestor_store = Store(data={"constitution": constitution})
ancestor = Agent("grandparent", ancestor_store, skills={}, generation=0)

# 第三步：创建父辈 Agent（继承祖辈 Store，只读）
parent_store = HierarchicalStore(parent=ancestor_store, readonly=True)
parent = Agent("coordinator", parent_store, 
               skills={"search_product": search_product},
               generation=1)

# 第四步：创建孙辈 Agent（继承父辈 Store，只读）
child_store = HierarchicalStore(parent=parent_store, readonly=True)
child = Agent("executor", child_store,
              skills={"generate_reply": generate_reply},
              generation=2)

# 第五步：定义并验证 SOP
customer_sop = SOP(
    name="handle_customer_inquiry",
    steps=["search_product", "generate_reply"],
    required_skills=["search_product", "generate_reply"]
)

# 宪法校验
try:
    validate_sop(ancestor_sop=ancestor.define_sop(constitution), 
                 descendant_sop=customer_sop)
    print("✅ SOP 合规，可以执行")
except SOPValidationError as e:
    print(f"❌ SOP 不合规: {e}")