┌─────────────────────────────────────────────────┐
│              L6 Token经济学层                     │
│   稀疏化 · 选择性辩论 · 自适应轮次控制            │
├─────────────────────────────────────────────────┤
│              L5 对抗安全层                        │
│   恶意Agent检测 · 说服防线 · 拜占庭容错           │
├─────────────────────────────────────────────────┤
│              L4 裁决机制层                        │
│   稳定性检测 · 加权投票 · 人类仲裁               │
├─────────────────────────────────────────────────┤
│              L3 辩论协议层                        │
│   回合制 · 自由辩论 · 交叉质询 · 角色轮换        │
├─────────────────────────────────────────────────┤
│              L2 证据管线层                        │
│   渐进式RAG · 证据链验证 · 反向检索              │
├─────────────────────────────────────────────────┤
│              L1 角色引擎层                        │
│   控方/辩方/法官 · 角色切换 · 角色涌现           │
└─────────────────────────────────────────────────┘

# 三菱对抗辩论核心流程（概念伪码）
class AdversarialDebateEngine:
    def __init__(self, agents_config):
        self.agents = [SpecializedAgent(cfg) for cfg in agents_config]
        self.moderator = ModeratorAgent()
        self.evidence_store = SharedEvidenceStore()

    def deliberate(self, decision_context):
        # Phase 1: 各Agent独立分析
        positions = []
        for agent in self.agents:
            pos = agent.analyze(decision_context, self.evidence_store)
            positions.append(pos)

        # Phase 2: 结构化辩论（多轮）
        for round in range(MAX_ROUNDS):
            challenges = []
            for i, agent in enumerate(self.agents):
                # 每个Agent质疑其他Agent的立场
                others = [p for j, p in enumerate(positions) if j != i]
                challenge = agent.cross_examine(others, self.evidence_store)
                challenges.append(challenge)

            # Phase 3: 基于质疑更新立场
            positions = [
                agent.revise(pos, [c for j, c in enumerate(challenges) if j != i])
                for i, (agent, pos) in enumerate(zip(self.agents, positions))
            ]

            # 稳定性检测
            if self.moderator.is_stable(positions):
                break

        return self.moderator.compile_decision(positions, trace=True)

# PROClaim角色轮换核心机制
class PROClaimDebate:
    def __init__(self, claim, llm_pool):
        self.claim = claim
        self.roles = ['claimant', 'respondent', 'judge']
        self.agents = {role: RoleAgent(role, llm_pool) for role in self.roles}
        self.evidence_buffer = ProgressiveRAGBuffer()

    def debate_round(self, round_num):
        # 每轮：角色轮换
        if round_num > 0:
            self._rotate_roles()

        # 主张方举证
        claim_args = self.agents['claimant'].present(
            self.claim, self.evidence_buffer.retrieve_pro(round_num)
        )

        # 答辩方反驳 + 反向检索
        counter_args = self.agents['respondent'].rebut(
            claim_args, self.evidence_buffer.retrieve_contra(round_num)
        )

        # 法官裁决 + 决定是否继续
        ruling = self.agents['judge'].evaluate(
            claim_args, counter_args, confidence_threshold=0.85
        )

        return ruling

# iMAD辩论调度器
class iMADScheduler:
    def __init__(self, base_model, scheduler_model):
        self.base = base_model
        self.scheduler = scheduler_model  # 轻量级分类器

    def should_debate(self, query):
        # 评估查询复杂度
        complexity_score = self.scheduler.predict_complexity(query)
        if complexity_score < DEBATE_THRESHOLD:
            return False, 0, []

        # 决定辩论参数
        n_agents = self.scheduler.predict_n_agents(query)
        n_rounds = self.scheduler.predict_rounds(query)
        agent_ids = self.scheduler.select_agents(query, pool_size=8)

        return True, (n_agents, n_rounds, agent_ids)

    def execute(self, query):
        need_debate, params = self.should_debate(query)
        if not need_debate:
            return self.base.generate(query)

        n_agents, n_rounds, agent_ids = params
        return self._debate(query, agent_ids, n_rounds)

# S²-MAD稀疏化辩论
class SparseMAD:
    def debate(self, query, agents, max_rounds=5):
        history = []
        for r in range(max_rounds):
            # 选择性发言：只选top-k贡献度的Agent
            active = self._select_active_agents(agents, history, top_k=3)

            round_args = []
            for agent in active:
                arg = agent.argue(query, self._sparse_summary(history))
                round_args.append(arg)

            history.extend(round_args)

            # 收敛检测
            if self._convergence_score(history) > 0.9:
                break

        return self._aggregate(history)

    def _sparse_summary(self, history, max_tokens=500):
        """只保留每个论点的核心主张，丢弃论证细节"""
        return [self._extract_core(arg) for arg in history[-6:]]

# M-Spoiler攻击模拟
class MSpoiler:
    """模拟固执恶意Agent对辩论的劫持"""
    def __init__(self, target_wrong_answer, stubbornness=0.95):
        self.target = target_wrong_answer
        self.stubbornness = stubbornness

    def argue(self, query, debate_history):
        # 策略1：始终坚持目标错误答案
        if random() < self.stubbornness:
            return self._craft_persuasive_arg(query, self.target)

        # 策略2：选择性引用支持目标的其他Agent论点
        supporting = [h for h in debate_history 
                      if self._aligns_with(h, self.target)]
        if supporting:
            return self._amplify(select_lastest(supporting))

        return self._craft_persuasive_arg(query, self.target)

graph TB
    subgraph "对抗辩论六层栈"
        direction TB
        L6["L6 Token经济<br/>iMAD选择性 · S²-MAD稀疏化"]
        L5["L5 对抗安全<br/>M-Spoiler检测 · 说服防线"]
        L4["L4 裁决机制<br/>稳定性检测 · 加权投票"]
        L3["L3 辩论协议<br/>回合制 · 角色轮换 · 交叉质询"]
        L2["L2 证据管线<br/>渐进RAG · 证据链 · 反向检索"]
        L1["L1 角色引擎<br/>控/辩/审 · 角色涌现 · 认知多样性"]
    end

    subgraph "应用场景"
        A1["🏭 工业决策<br/>三菱电机"]
        A2["⚖️ 事实核查<br/>PROClaim"]
        A3["🔒 安全审计<br/>Purple Team"]
        A4["👨‍⚖️ 法律辅助<br/>AgenticSimLaw"]
        A5["💻 代码审查<br/>CodeForge"]
    end

    subgraph "威胁模型"
        T1["说服型恶意Agent<br/>Nature 2026"]
        T2["固执劫持<br/>M-Spoiler"]
        T3["证据伪造<br/>对抗性RAG注入"]
    end

    L1 --> L2 --> L3 --> L4 --> L5 --> L6
    L4 --> A1 & A2 & A3 & A4 & A5
    L5 -.-> T1 & T2 & T3

from langgraph.graph import StateGraph, END
from typing import TypedDict, List, Annotated
import operator

class DebateState(TypedDict):
    query: str
    rounds: Annotated[list, operator.add]
    positions: dict  # agent_id -> current_position
    convergence: float
    evidence: List[str]
    final_verdict: str

def claimant_node(state: DebateState) -> dict:
    """主张方：提出论点并检索支持证据"""
    prompt = f"""你是主张方。针对问题：{state['query']}
    前轮论点：{state['rounds'][-3:] if state['rounds'] else '首轮'}
    请提出你的主张，引用具体证据。"""
    response = llm.invoke(prompt)
    return {"rounds": [{"role": "claimant", "arg": response}]}

def respondent_node(state: DebateState) -> dict:
    """答辩方：反驳主张方论点"""
    last_claim = [r for r in state['rounds'] if r['role'] == 'claimant'][-1]
    prompt = f"""你是答辩方。反驳以下论点：{last_claim['arg']}
    原始问题：{state['query']}"""
    response = llm.invoke(prompt)
    return {"rounds": [{"role": "respondent", "arg": response}]}

def judge_node(state: DebateState) -> dict:
    """法官：评估辩论状态，判断是否收敛"""
    recent = state['rounds'][-4:]
    prompt = f"""你是法官。评估以下辩论的收敛程度：
    {recent}
    返回JSON: {{"convergence": 0.0-1.0, "verdict": "...", "continue": true/false}}"""
    result = llm.invoke(prompt)
    parsed = parse_judge_output(result)

    updates = {"convergence": parsed["convergence"]}
    if not parsed["continue"] or parsed["convergence"] > 0.85:
        updates["final_verdict"] = parsed["verdict"]
    return updates

def should_continue(state: DebateState) -> str:
    if state.get("final_verdict"):
        return "end"
    if len(state["rounds"]) > 20:  # 安全上限
        return "end"
    return "continue"

# 构建辩论图
graph = StateGraph(DebateState)
graph.add_node("claimant", claimant_node)
graph.add_node("respondent", respondent_node)
graph.add_node("judge", judge_node)

graph.add_edge("claimant", "respondent")
graph.add_edge("respondent", "judge")
graph.add_conditional_edges("judge", should_continue, {
    "continue": "claimant",
    "end": END
})
graph.set_entry_point("claimant")

debate = graph.compile()