《八部半》与多重签名：费里尼的创作困境作为多签治理

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract OttoEMezzoMultiSig is AccessControl, ReentrancyGuard {
    bytes32 public constant SIGNER_ROLE = keccak256("SIGNER_ROLE");
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");

    enum IdentityType {
        DIRECTOR,       // 导演 - 创作决策
        PRODUCER,       // 制片人 - 财务决策
        SCREENWRITER,   // 编剧 - 叙事决策
        CINEMATOGRAPHER,// 摄影 - 视觉决策
        ACTOR,          // 演员 - 表演决策
        COMPOSER,        // 作曲家 - 音乐决策
        CRITIC,         // 评论家 - 外部声音
        DISTRIBUTOR,    // 发行商 - 商业决策
        INVESTOR,       // 投资者 - 资本决策
        MUSE            // 缪斯 - 灵感来源
    }

    enum DecisionType {
        CREATIVE,       // 创作决策
        FINANCIAL,      // 财务决策
        PRODUCTION,     // 制作决策
        DISTRIBUTION,   // 发行决策
        CASTING,        // 选角决策
        EXISTENTIAL     // 存在性决策
    }

    enum DecisionStatus {
        PENDING,
        APPROVED,
        REJECTED,
        STALLED,
        WITHDRAWN,
        ESCALATED
    }

    enum CrisisLevel {
        INSPIRATION,    // 灵感充沛
        MILD_DOUBT,     // 轻度怀疑
        CREATIVE_BLOCK, // 创作瓶颈
        EXISTENTIAL     // 存在危机
    }

    struct CreativeIdentity {
        address identityAddress;
        string name;
        IdentityType identityType;
        uint256 influenceWeight;    // 影响力权重 (0-1000)
        uint256 vetoPower;          // 否决权 (0 = 无, 1 = 有)
        uint256 decisionsMade;
        uint256 decisionsVetoed;
        bool isActive;
        string manifestoURI;
    }

    struct Decision {
        uint256 decisionId;
        address[] initiators;
        string description;
        DecisionType decisionType;
        DecisionStatus status;
        CrisisLevel crisisLevel;
        uint256 yesVotes;
        uint256 noVotes;
        uint256 abstainVotes;
        uint256 requiredApprovals;
        uint256 totalSigners;
        uint256 createdAt;
        uint256 deadline;
        uint256 executedAt;
        bytes32 decisionHash;
        string ipfsDocumentURI;
        bool isExecuted;
        address[] approvedSigners;
        address[] rejectedSigners;
    }

    struct CreativeVeto {
        uint256 vetoId;
        uint256 decisionId;
        address vetoer;
        IdentityType vetoerType;
        string reason;
        uint256 timestamp;
        bool isOverridden;
    }

    struct CrisisJournal {
        uint256 entryId;
        address signer;
        string dreamSequenceURI;
        string reflection;
        uint256 timestamp;
        CrisisLevel crisisLevel;
    }

    mapping(address => CreativeIdentity) public identities;
    mapping(uint256 => Decision) public decisions;
    mapping(uint256 => CreativeVeto) public vetos;
    mapping(uint256 => CrisisJournal) public journals;
    mapping(address => uint256[]) public signerDecisions;
    mapping(uint256 => mapping(address => bool)) public hasVoted;

    uint256 private _decisionCounter;
    uint256 private _vetoCounter;
    uint256 private _journalCounter;
    uint256 public constant MAX_DECISION_DURATION = 30 days;
    uint256 public constant MIN_APPROVAL_RATIO = 600; // 60%

    event DecisionCreated(
        uint256 indexed decisionId,
        string description,
        DecisionType decisionType,
        CrisisLevel crisisLevel
    );

    event VoteCast(
        uint256 indexed decisionId,
        address indexed signer,
        bool approved
    );

    event DecisionExecuted(
        uint256 indexed decisionId,
        bool approved
    );

    event VetoCasted(
        uint256 indexed vetoId,
        uint256 indexed decisionId,
        address indexed vetoer,
        string reason
    );

    event CrisisJournalEntry(
        uint256 indexed entryId,
        address indexed signer,
        CrisisLevel crisisLevel
    );

    modifier onlySigner() {
        require(identities[msg.sender].isActive, "Not active signer");
        _;
    }

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(ADMIN_ROLE, msg.sender);
        _grantRole(SIGNER_ROLE, msg.sender);
    }

    function registerIdentity(
        address _identity,
        string memory _name,
        IdentityType _identityType,
        uint256 _influenceWeight,
        bool _hasVetoPower,
        string memory _manifestoURI
    ) external onlyRole(ADMIN_ROLE) {
        require(_influenceWeight <= 1000, "Invalid weight");

        identities[_identity] = CreativeIdentity({
            identityAddress: _identity,
            name: _name,
            identityType: _identityType,
            influenceWeight: _influenceWeight,
            vetoPower: _hasVetoPower ? 1 : 0,
            decisionsMade: 0,
            decisionsVetoed: 0,
            isActive: true,
            manifestoURI: _manifestoURI
        });

        _grantRole(SIGNER_ROLE, _identity);
    }

    function createDecision(
        string memory _description,
        DecisionType _decisionType,
        CrisisLevel _crisisLevel,
        uint256 _deadline,
        string memory _ipfsDocumentURI,
        address[] memory _initiators
    ) external onlySigner returns (uint256) {
        require(_deadline > block.timestamp && _deadline <= block.timestamp + MAX_DECISION_DURATION, "Invalid deadline");

        _decisionCounter++;
        uint256 decisionId = _decisionCounter;

        uint256 activeSigners = _getActiveSignerCount();
        uint256 required = (activeSigners * MIN_APPROVAL_RATIO) / 1000;
        if (required < 1) required = 1;

        decisions[decisionId] = Decision({
            decisionId: decisionId,
            initiators: _initiators,
            description: _description,
            decisionType: _decisionType,
            status: DecisionStatus.PENDING,
            crisisLevel: _crisisLevel,
            yesVotes: 0,
            noVotes: 0,
            abstainVotes: 0,
            requiredApprovals: required,
            totalSigners: activeSigners,
            createdAt: block.timestamp,
            deadline: _deadline,
            executedAt: 0,
            decisionHash: keccak256(abi.encodePacked(decisionId, _description, block.timestamp)),
            ipfsDocumentURI: _ipfsDocumentURI,
            isExecuted: false,
            approvedSigners: new address[](0),
            rejectedSigners: new address[](0)
        });

        emit DecisionCreated(decisionId, _description, _decisionType, _crisisLevel);
        return decisionId;
    }

    function castVote(
        uint256 _decisionId,
        bool _approve,
        bool _abstain
    ) external onlySigner {
        Decision storage decision = decisions[_decisionId];
        require(decision.status == DecisionStatus.PENDING, "Decision not pending");
        require(block.timestamp < decision.deadline, "Voting period ended");
        require(!hasVoted[_decisionId][msg.sender], "Already voted");

        hasVoted[_decisionId][msg.sender] = true;

        if (_abstain) {
            decision.abstainVotes++;
        } else if (_approve) {
            decision.yesVotes++;
            decision.approvedSigners.push(msg.sender);
        } else {
            decision.noVotes++;
            decision.rejectedSigners.push(msg.sender);
        }

        signerDecisions[msg.sender].push(_decisionId);
        identities[msg.sender].decisionsMade++;

        emit VoteCast(_decisionId, msg.sender, _approve);

        _checkDecisionStatus(_decisionId);
    }

    function castVeto(
        uint256 _decisionId,
        string memory _reason
    ) external onlySigner returns (uint256) {
        CreativeIdentity storage identity = identities[msg.sender];
        require(identity.vetoPower == 1, "No veto power");
        require(decisionStatus(_decisionId) == DecisionStatus.PENDING, "Not pending");

        _vetoCounter++;
        uint256 vetoId = _vetoCounter;

        vetos[vetoId] = CreativeVeto({
            vetoId: vetoId,
            decisionId: _decisionId,
            vetoer: msg.sender,
            vetoerType: identity.identityType,
            reason: _reason,
            timestamp: block.timestamp,
            isOverridden: false
        });

        identity.decisionsVetoed++;

        // 否决权：直接阻止决策
        decisions[_decisionId].status = DecisionStatus.STALLED;

        emit VetoCasted(vetoId, _decisionId, msg.sender, _reason);
        return vetoId;
    }

    function overrideVeto(
        uint256 _vetoId,
        uint256 _overrideVotes
    ) external onlyRole(ADMIN_ROLE) {
        CreativeVeto storage veto = vetos[_vetoId];
        require(!veto.isOverridden, "Already overridden");

        // 需要2/3超级多数来推翻否决
        uint256 activeSigners = _getActiveSignerCount();
        uint256 overrideThreshold = (activeSigners * 667) / 1000;

        if (_overrideVotes >= overrideThreshold) {
            veto.isOverridden = true;
            decisions[veto.decisionId].status = DecisionStatus.PENDING;
        }
    }

    function executeDecision(uint256 _decisionId) external onlyRole(ADMIN_ROLE) {
        Decision storage decision = decisions[_decisionId];
        require(decision.status == DecisionStatus.APPROVED, "Not approved");
        require(!decision.isExecuted, "Already executed");

        decision.isExecuted = true;
        decision.executedAt = block.timestamp;

        emit DecisionExecuted(_decisionId, true);
    }

    function enterCrisisJournal(
        string memory _dreamSequenceURI,
        string memory _reflection,
        CrisisLevel _crisisLevel
    ) external onlySigner returns (uint256) {
        _journalCounter++;
        uint256 entryId = _journalCounter;

        journals[entryId] = CrisisJournal({
            entryId: entryId,
            signer: msg.sender,
            dreamSequenceURI: _dreamSequenceURI,
            reflection: _reflection,
            timestamp: block.timestamp,
            crisisLevel: _crisisLevel
        });

        emit CrisisJournalEntry(entryId, msg.sender, _crisisLevel);
        return entryId;
    }

    function _checkDecisionStatus(uint256 _decisionId) internal {
        Decision storage decision = decisions[_decisionId];

        // 检查是否达到批准阈值
        if (decision.yesVotes >= decision.requiredApprovals) {
            decision.status = DecisionStatus.APPROVED;
        }
        // 检查是否被拒绝（超过半数反对）
        else if (decision.noVotes > decision.totalSigners / 2) {
            decision.status = DecisionStatus.REJECTED;
        }
        // 检查是否过期
        else if (block.timestamp >= decision.deadline) {
            if (decision.yesVotes > decision.noVotes) {
                decision.status = DecisionStatus.APPROVED;
            } else {
                decision.status = DecisionStatus.REJECTED;
            }
        }
    }

    function _getActiveSignerCount() internal view returns (uint256) {
        uint256 count = 0;
        // In production, this would iterate over a signer list
        // For simplicity, we return a placeholder
        return count;
    }

    function decisionStatus(uint256 _decisionId) public view returns (DecisionStatus) {
        if (block.timestamp >= decisions[_decisionId].deadline && 
            decisions[_decisionId].status == DecisionStatus.PENDING) {
            return DecisionStatus.STALLED;
        }
        return decisions[_decisionId].status;
    }

    function getIdentityInfo(address _identity) external view returns (CreativeIdentity memory) {
        return identities[_identity];
    }

    function getDecisionDetails(uint256 _decisionId) external view returns (Decision memory) {
        return decisions[_decisionId];
    }

    function getSignerDecisions(address _signer) external view returns (uint256[] memory) {
        return signerDecisions[_signer];
    }
}

import json
import time
import hashlib
import random
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple
from enum import Enum

class IdentityType(Enum):
    DIRECTOR = "director"
    PRODUCER = "producer"
    SCREENWRITER = "screenwriter"
    ACTOR = "actor"
    COMPOSER = "composer"
    CRITIC = "critic"
    INVESTOR = "investor"
    MUSE = "muse"

class DecisionType(Enum):
    CREATIVE = "creative"
    FINANCIAL = "financial"
    PRODUCTION = "production"
    CASTING = "casting"
    DISTRIBUTION = "distribution"
    EXISTENTIAL = "existential"

class DecisionStatus(Enum):
    PENDING = "pending"
    APPROVED = "approved"
    REJECTED = "rejected"
    STALLED = "stalled"
    VETOED = "vetoed"

class CrisisLevel(Enum):
    INSPIRATION = "inspiration"
    MILD_DOUBT = "mild_doubt"
    CREATIVE_BLOCK = "creative_block"
    EXISTENTIAL = "existential_crisis"

@dataclass
class CreativeSigner:
    address: str
    name: str
    identity_type: IdentityType
    weight: int
    has_veto: bool
    decisions_made: int
    is_active: bool

@dataclass
class MultiSigDecision:
    decision_id: int
    description: str
    decision_type: DecisionType
    crisis_level: CrisisLevel
    yes_votes: int
    no_votes: int
    abstain_votes: int
    required: int
    total_signers: int
    status: DecisionStatus
    deadline: int
    created_at: int
    approved_by: List[str]
    rejected_by: List[str]

@dataclass
class VetoRecord:
    veto_id: int
    decision_id: int
    vetoer: str
    reason: str
    overridden: bool


class OttoEMezzoMultiSig:
    """
    《八部半》多重签名治理模拟器
    """

    def __init__(self):
        self.signers: Dict[str, CreativeSigner] = {}
        self.decisions: Dict[int, MultiSigDecision] = {}
        self.vetos: Dict[int, VetoRecord] = {}
        self.decision_counter = 0
        self.veto_counter = 0

    def _hash(self, *args) -> str:
        return hashlib.sha256(":".join(str(a) for a in args).encode()).hexdigest()

    def register_creative_identity(
        self,
        address: str,
        name: str,
        identity_type: IdentityType,
        weight: int = 100,
        has_veto: bool = False
    ) -> CreativeSigner:
        signer = CreativeSigner(
            address=address,
            name=name,
            identity_type=identity_type,
            weight=weight,
            has_veto=has_veto,
            decisions_made=0,
            is_active=True
        )

        self.signers[address] = signer

        print(f"[注册] {name} ({identity_type.value})")
        print(f"  权重: {weight}, 否决权: {has_veto}")

        return signer

    def create_decision(
        self,
        initiator: str,
        description: str,
        decision_type: DecisionType,
        crisis_level: CrisisLevel,
        deadline: int = 86400 * 7
    ) -> int:
        if initiator not in self.signers:
            raise ValueError(f"签名人 {initiator[:8]} 未注册")

        self.decision_counter += 1
        decision_id = self.decision_counter

        active_signers = [s for s in self.signers.values() if s.is_active]
        required = max(1, int(len(active_signers) * 0.6))

        decision = MultiSigDecision(
            decision_id=decision_id,
            description=description,
            decision_type=decision_type,
            crisis_level=crisis_level,
            yes_votes=0,
            no_votes=0,
            abstain_votes=0,
            required=required,
            total_signers=len(active_signers),
            status=DecisionStatus.PENDING,
            deadline=int(time.time()) + deadline,
            created_at=int(time.time()),
            approved_by=[],
            rejected_by=[]
        )

        self.decisions[decision_id] = decision

        print(f"[决策] #{decision_id}: {description[:40]}...")
        print(f"  类型: {decision_type.value}, 危机: {crisis_level.value}")
        print(f"  需要: {required}/{len(active_signers)} 签名")

        return decision_id

    def cast_vote(
        self,
        decision_id: int,
        voter: str,
        approve: bool,
        abstain: bool = False
    ) -> bool:
        if decision_id not in self.decisions:
            raise ValueError(f"决策 #{decision_id} 不存在")
        if voter not in self.signers:
            raise ValueError(f"签名人 {voter[:8]} 未注册")

        decision = self.decisions[decision_id]
        signer = self.signers[voter]

        if decision.status != DecisionStatus.PENDING:
            raise ValueError(f"决策 #{decision_id} 状态为 {decision.status.value}")

        if int(time.time()) >= decision.deadline:
            decision.status = DecisionStatus.STALLED
            raise ValueError(f"决策 #{decision_id} 已过期")

        if abstain:
            decision.abstain_votes += 1
            print(f"[投票] {signer.name}: 弃权")
        elif approve:
            decision.yes_votes += 1
            decision.approved_by.append(voter)
            print(f"[投票] {signer.name}: 赞成")
        else:
            decision.no_votes += 1
            decision.rejected_by.append(voter)
            print(f"[投票] {signer.name}: 反对")

        signer.decisions_made += 1
        self._check_status(decision_id)

        return True

    def cast_veto(self, decision_id: int, vetoer: str, reason: str) -> int:
        if decision_id not in self.decisions:
            raise ValueError(f"决策 #{decision_id} 不存在")
        if vetoer not in self.signers:
            raise ValueError(f"签名人 {vetoer[:8]} 未注册")

        signer = self.signers[vetoer]
        if not signer.has_veto:
            raise ValueError(f"{signer.name} 没有否决权")

        decision = self.decisions[decision_id]
        if decision.status != DecisionStatus.PENDING:
            raise ValueError(f"决策 #{decision_id} 不能否决")

        self.veto_counter += 1
        veto_id = self.veto_counter

        veto = VetoRecord(
            veto_id=veto_id,
            decision_id=decision_id,
            vetoer=vetoer,
            reason=reason,
            overridden=False
        )

        self.vetos[veto_id] = veto
        decision.status = DecisionStatus.VETOED

        print(f"[否决] #{veto_id}: {signer.name} 否决了决策 #{decision_id}")
        print(f"  理由: {reason}")

        return veto_id

    def override_veto(self, veto_id: int, override_votes: int) -> bool:
        if veto_id not in self.vetos:
            raise ValueError(f"否决 #{veto_id} 不存在")

        veto = self.vetos[veto_id]
        if veto.overridden:
            raise ValueError("否决已被推翻")

        active_signers = [s for s in self.signers.values() if s.is_active]
        threshold = int(len(active_signers) * 0.667)  # 2/3 超级多数

        if override_votes >= threshold:
            veto.overridden = True
            self.decisions[veto.decision_id].status = DecisionStatus.PENDING
            print(f"[推翻] 否决 #{veto_id} 被 {override_votes} 票推翻")
            return True
        else:
            print(f"[失败] 需要 {threshold} 票，只有 {override_votes} 票")
            return False

    def _check_status(self, decision_id: int):
        decision = self.decisions[decision_id]

        if decision.yes_votes >= decision.required:
            decision.status = DecisionStatus.APPROVED
            print(f"[通过] 决策 #{decision_id}: 已批准")
        elif decision.no_votes > decision.total_signers / 2:
            decision.status = DecisionStatus.REJECTED
            print(f"[拒绝] 决策 #{decision_id}: 已拒绝")
        elif int(time.time()) >= decision.deadline:
            decision.status = DecisionStatus.STALLED
            print(f"[停滞] 决策 #{decision_id}: 已过期")

    def get_decision_timeline(self, decision_id: int) -> Dict:
        if decision_id not in self.decisions:
            raise ValueError(f"决策 #{decision_id} 不存在")

        decision = self.decisions[decision_id]

        return {
            "decision_id": decision_id,
            "description": decision.description[:50],
            "type": decision.decision_type.value,
            "crisis": decision.crisis_level.value,
            "status": decision.status.value,
            "votes": {
                "yes": decision.yes_votes,
                "no": decision.no_votes,
                "abstain": decision.abstain_votes,
                "required": decision.required,
                "total": decision.total_signers
            },
            "approved_by": [self.signers.get(a, CreativeSigner("", "未知", IdentityType.CRITIC, 0, False, 0, False)).name for a in decision.approved_by],
            "rejected_by": [self.signers.get(a, CreativeSigner("", "未知", IdentityType.CRITIC, 0, False, 0, False)).name for a in decision.rejected_by],
            "created": time.strftime("%Y-%m-%d %H:%M", time.gmtime(decision.created_at)),
            "deadline": time.strftime("%Y-%m-%d %H:%M", time.gmtime(decision.deadline))
        }

    def simulate_fellini_crisis(self) -> Dict:
        """
        模拟费里尼的创作困境作为多签治理
        """
        print(f"\n{'='*60}")
        print(f"  《八部半》多签治理模拟")
        print(f"  费里尼的创作困境作为多签治理")
        print(f"{'='*60}\n")

        # 1. 注册所有"声音"
        print(">>> 1. 注册创作身份\n")
        guido = self.register_creative_identity("0xGuido...Director", "圭多·安塞尔米（导演）", IdentityType.DIRECTOR, weight=300, has_veto=True)
        producer = self.register_creative_identity("0xProd...Producer", "制片人", IdentityType.PRODUCER, weight=200, has_veto=True)
        writer = self.register_creative_identity("0xWriter...Screenwriter", "编剧", IdentityType.SCREENWRITER, weight=150)
        actor = self.register_creative_identity("0xActor...Lead", "男主角", IdentityType.ACTOR, weight=100)
        composer = self.register_creative_identity("0xComp...Composer", "作曲家", IdentityType.COMPOSER, weight=80)
        critic = self.register_creative_identity("0xCritic...Reviewer", "评论家", IdentityType.CRITIC, weight=50)
        investor = self.register_creative_identity("0xInvest...Fund", "投资者", IdentityType.INVESTOR, weight=200, has_veto=True)
        muse = self.register_creative_identity("0xMuse...Claudia", "缪斯（克劳迪娅）", IdentityType.MUSE, weight=120)

        # 2. 创作决策的困境
        print("\n>>> 2. 创作决策困境\n")
        print("圭多面临多重决策困境：")
        print("  - 制片人: 要求商业化的科幻片")
        print("  - 编剧: 建议文艺片")
        print("  - 投资者: 要求确保回报")
        print("  - 评论家: 期待艺术突破")
        print("  - 缪斯: 提供灵感但不做决定")

        # 3. 第一个决策：选片
        print("\n>>> 3. 决策1: 下一部电影类型\n")
        d1 = self.create_decision(
            initiator=guido.address,
            description="下一部电影应该是科幻片还是文艺片？",
            decision_type=DecisionType.CREATIVE,
            crisis_level=CrisisLevel.CREATIVE_BLOCK,
            deadline=86400 * 7
        )

        self.cast_vote(d1, producer.address, True)  # 制片人支持科幻片
        self.cast_vote(d1, writer.address, False)    # 编剧反对
        self.cast_vote(d1, investor.address, True)   # 投资者支持
        self.cast_vote(d1, critic.address, False)    # 评论家反对
        self.cast_vote(d1, composer.address, True)   # 作曲家支持
        self.cast_vote(d1, actor.address, True)      # 演员支持

        # 圭多（导演）陷入困境，无法决定
        print(f"\n  圭多陷入困境，无法决定...")

        # 4. 第二个决策：选角
        print("\n>>> 4. 决策2: 女主角选角\n")
        d2 = self.create_decision(
            initiator=producer.address,
            description="女主角应该选知名明星还是新人？",
            decision_type=DecisionType.CASTING,
            crisis_level=CrisisLevel.MILD_DOUBT,
            deadline=86400 * 5
        )

        self.cast_vote(d2, producer.address, True)   # 制片人要明星
        self.cast_vote(d2, investor.address, True)    # 投资者要明星
        self.cast_vote(d2, critic.address, False)     # 评论家要新人
        self.cast_vote(d2, actor.address, False)      # 演员要新人

        # 5. 第三个决策：存在性危机
        print("\n>>> 5. 决策3: 是否继续拍摄？\n")
        d3 = self.create_decision(
            initiator=guido.address,
            description="是否应该继续拍摄这部没有灵感的电影？",
            decision_type=DecisionType.EXISTENTIAL,
            crisis_level=CrisisLevel.EXISTENTIAL,
            deadline=86400 * 3
        )

        # 圭多使用否决权
        self.cast_veto(d3, guido.address, "我需要更多时间来找到灵感")

        # 6. 第四个决策：预算
        print("\n>>> 6. 决策4: 预算分配\n")
        d4 = self.create_decision(
            initiator=producer.address,
            description="是否增加特效预算？",
            decision_type=DecisionType.FINANCIAL,
            crisis_level=CrisisLevel.MILD_DOUBT,
            deadline=86400 * 4
        )

        self.cast_vote(d4, producer.address, True)
        self.cast_vote(d4, investor.address, True)
        self.cast_vote(d4, composer.address, False)
        self.cast_vote(d4, writer.address, False)

        # 投资者否决
        self.cast_veto(d4, investor.address, "预算已经超支")

        # 7. 决策时间线
        print("\n>>> 7. 决策时间线\n")
        for did in [d1, d2, d3, d4]:
            timeline = self.get_decision_timeline(did)
            print(f"  #{did} [{timeline['status']}]: {timeline['description']}")
            print(f"    赞成: {timeline['votes']['yes']}/{timeline['votes']['required']}")
            print(f"    反对: {timeline['votes']['no']}")
            print(f"    通过者: {', '.join(timeline['approved_by']) if timeline['approved_by'] else '无'}")

        # 8. 费里尼解决方案
        print("\n>>> 8. 费里尼的解决方案：接受多重声音\n")
        print("""
        圭多最终意识到：创作困境不是"选择"的问题，
        而是"接受"的问题——接受所有声音的存在，
        接受不确定性的必然性，接受不完美的可能性。
        
        在多重签名治理中，这意味着：
        - 不是所有决策都需要"立即"做出
        - 不是所有分歧都需要"消除"
        - 不是所有决策都是"完美"的
        - "停滞"有时比"糟糕的决策"更好
        """)

        print(f"\n{'='*60}")
        print(f"  模拟完成")
        print(f"{'='*60}")

        return {
            "total_decisions": 4,
            "approved": sum(1 for d in self.decisions.values() if d.status == DecisionStatus.APPROVED),
            "rejected": sum(1 for d in self.decisions.values() if d.status == DecisionStatus.REJECTED),
            "vetoed": sum(1 for d in self.decisions.values() if d.status == DecisionStatus.VETOED),
            "stalled": sum(1 for d in self.decisions.values() if d.status == DecisionStatus.STALLED),
            "total_signers": len(self.signers)
        }


def main():
    multisig = OttoEMezzoMultiSig()
    result = multisig.simulate_fellini_crisis()

    print(f"\n=== 模拟结果 ===")
    print(f"总决策: {result['total_decisions']}")
    print(f"通过: {result['approved']}, 拒绝: {result['rejected']}")
    print(f"否决: {result['vetoed']}, 停滞: {result['stalled']}")
    print(f"签名人: {result['total_signers']}")


if __name__ == "__main__":
    main()