mss-agent 0.1.0__py3-none-any.whl

core/__init__.py

@@ -0,0 +1,6 @@
+from .agent import MSSAgent, AgentResult
+from .heat_tax import HeatTaxBudget, HeatTaxLevel, HeatTaxAbort
+from .delta import DeltaProtocol
+from .memory import DeltaMemory
+
+__all__ = ["MSSAgent", "AgentResult", "HeatTaxBudget", "HeatTaxLevel", "HeatTaxAbort", "DeltaProtocol", "DeltaMemory"]

core/agent.py

@@ -0,0 +1,198 @@
+"""
+MSS-Agent 核心基类 — 三层防御的自主 Agent.
+
+每个 MSSAgent 实例携带:
+  L0 热税预算 (A3) — 拒绝无意义任务
+  L1 Δ检测协议 (A6) — 检测闭合, 触发蜕壳
+  L2 记忆系统     — 不记住一切, 遗忘旧模式
+
+Usage:
+    agent = MSSAgent(name="Writer", llm=my_llm_fn)
+    result = agent.run("写一篇关于 AI 安全的文章")
+    if result.aborted:
+        print(f"Agent 拒绝: {result.reason}")
+    agent.health_report()
+"""
+from dataclasses import dataclass, field
+from typing import Optional, Callable, Any
+import hashlib
+import time
+
+from .heat_tax import HeatTaxBudget, HeatTaxLevel, HeatTaxAbort
+from .delta import DeltaProtocol
+from .memory import DeltaMemory
+
+
+@dataclass
+class AgentResult:
+    """Agent 执行结果."""
+    success: bool
+    output: Any = None
+    aborted: bool = False
+    reason: str = ""
+    heat_tax: dict = field(default_factory=dict)
+    delta: float = 0.0
+    elapsed_ms: float = 0.0
+
+
+class MSSAgent:
+    """
+    MSS-Agent 基类.
+
+    所有 Agent (Writer/Reviewer/Analyst) 继承此类.
+    核心循环: think → heat_tax_check → act → delta_tick → remember
+
+    Args:
+        name: Agent 名称
+        llm: LLM 调用函数 (prompt) -> str
+        heat_tax_threshold: 热税预算上限 (default 0.5)
+        delta_min: Δ 最低阈值 (default 0.3)
+    """
+
+    def __init__(
+        self,
+        name: str,
+        llm: Optional[Callable[[str], str]] = None,
+        heat_tax_threshold: float = 2.0,
+        delta_min: float = 0.3,
+    ):
+        self.name = name
+        self.llm = llm or (lambda p: f"[{name}] LLM not configured. Prompt: {p[:80]}...")
+        self.tax = HeatTaxBudget(threshold=heat_tax_threshold)
+        self.delta = DeltaProtocol(min_delta=delta_min)
+        self.memory = DeltaMemory()
+        self.run_count = 0
+        self.abort_count = 0
+
+    def _task_hash(self, prompt: str) -> str:
+        return hashlib.md5(prompt.encode()).hexdigest()[:12]
+
+    def _estimate_meaning_heat(self, prompt: str) -> tuple[float, str]:
+        """
+        评估任务的意义热税. 基于 LLM 自省.
+
+        高意义热税 = 任务可能在浪费生命.
+        启发式:
+          - 空 prompt / 纯废话 → high heat
+          - 含 '为什么' / '怎么' / '分析' → low heat (有意义)
+          - <=20 chars → suspicious
+
+        Returns (heat_value, reason). heat_value: 0.0=very meaningful, 1.0=meaningless.
+        Note: L2 weight is 1000x, so even 0.001 matters. Calibrate carefully.
+        """
+        prompt_lower = prompt.lower().strip()
+
+        # Heuristic: meaningful keywords reduce heat tax
+        meaning_signals = ["为什么", "怎么", "分析", "评估", "设计", "实现",
+                           "why", "how", "analyze", "design", "implement",
+                           "review", "refactor", "test", "debug"]
+        meaning_score = sum(1 for s in meaning_signals if s in prompt_lower)
+
+        # Wasted-life signals increase heat tax
+        waste_signals = ["帮我写", "改写一下", "翻译成", "总结一下", "简短点"]
+        waste_score = sum(1 for s in waste_signals if s in prompt_lower)
+
+        if len(prompt) < 5:
+            return 0.08, "Prompt <5 chars: likely trivial"
+
+        if waste_score > meaning_score and waste_score >= 2:
+            return 0.05, "Task smells like busywork (high waste signals)"
+
+        if meaning_score >= 2:
+            return 0.002, "Task has clear meaningful intent"
+
+        if meaning_score >= 1:
+            return 0.005, "Task has some meaningful intent"
+
+        return 0.01, "Task assessed as neutral"
+
+    def run(self, prompt: str) -> AgentResult:
+        """
+        运行 Agent 的核心循环.
+
+        1. 评估意义热税 → 如果过高 → 拒绝
+        2. 执行 LLM 调用
+        3. 记录热税
+        4. Δ tick + memory store
+        """
+        t0 = time.time()
+        self.run_count += 1
+        task_hash = self._task_hash(prompt)
+
+        # L2: 意义热税评估
+        meaning_heat, meaning_reason = self._estimate_meaning_heat(prompt)
+        self.tax.charge(HeatTaxLevel.L2_MEANING, meaning_heat, meaning_reason)
+
+        if self.tax.l2_dominant() and meaning_heat > 0.05:
+            self.abort_count += 1
+            return AgentResult(
+                success=False, aborted=True,
+                reason=f"Task has LOW meaning: {meaning_reason}",
+                heat_tax=self.tax.snapshot(),
+                elapsed_ms=(time.time() - t0) * 1000,
+            )
+
+        # L1: Check total budget
+        if self.tax.exceeded():
+            self.abort_count += 1
+            return AgentResult(
+                success=False, aborted=True,
+                reason=f"Heat tax budget exceeded: {self.tax.total():.3f}",
+                heat_tax=self.tax.snapshot(),
+                elapsed_ms=(time.time() - t0) * 1000,
+            )
+
+        # Execute
+        try:
+            output = self.llm(prompt)
+        except Exception as e:
+            self.tax.charge(HeatTaxLevel.L1_LOGICAL, 0.05, f"LLM error: {str(e)[:60]}")
+            return AgentResult(
+                success=False, aborted=True, reason=str(e),
+                heat_tax=self.tax.snapshot(),
+                elapsed_ms=(time.time() - t0) * 1000,
+            )
+
+        # L1: Charge logical heat (token count proxy)
+        token_estimate = len(output) / 4  # ~4 chars per token
+        self.tax.charge(HeatTaxLevel.L1_LOGICAL, token_estimate * 0.0001, f"{int(token_estimate)} tokens")
+
+        # L0: Physical heat (always tiny)
+        elapsed = (time.time() - t0) * 1000
+        self.tax.charge(HeatTaxLevel.L0_PHYSICAL, elapsed * 0.00001, f"{elapsed:.0f}ms")
+
+        # Δ tick: novelty + diversity → delta
+        novelty = self.memory.novelty_score(prompt)
+        diversity = self.memory.diversity_score()
+        current_delta = self.delta.tick(task_hash, novelty, diversity)
+
+        # Store in memory
+        self.memory.store(prompt, current_delta)
+
+        return AgentResult(
+            success=True,
+            output=output,
+            aborted=False,
+            heat_tax=self.tax.snapshot(),
+            delta=current_delta,
+            elapsed_ms=elapsed,
+        )
+
+    def health_report(self) -> dict:
+        """输出 Agent 健康报告."""
+        return {
+            "agent": self.name,
+            "runs": self.run_count,
+            "aborts": self.abort_count,
+            "abort_rate": round(self.abort_count / max(self.run_count, 1), 3),
+            "heat_tax": self.tax.snapshot(),
+            "delta": self.delta.snapshot(),
+            "memory": self.memory.stats(),
+        }
+
+    def reset(self):
+        """重置 Agent (保留 memory)."""
+        self.tax = HeatTaxBudget(threshold=self.tax.threshold)
+        self.delta = DeltaProtocol(min_delta=self.delta.min_delta)
+        self.run_count = 0
+        self.abort_count = 0

core/delta.py

@@ -0,0 +1,78 @@
+"""
+Δ 维持条件 — MSS-Agent 的第二道防线.
+
+Δ 不是优化目标, 是存活条件 (心率>0, 不是最大化心率).
+Δ<0 → Agent 闭合于旧模式 → 触发蜕壳.
+"""
+import time
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class DeltaProtocol:
+    """
+    Δ 检测协议 (H528). 嵌入每个 Agent 实例.
+
+    min_delta: Δ 最低阈值 (0.3). 低于此→告警
+    molt_cycles: 连续下降 N 个周期→触发蜕壳
+    """
+    min_delta: float = 0.3
+    molt_cycles: int = 2
+    history: list = field(default_factory=list)  # [{ts, delta, task_hash}]
+    molting_alert: bool = False
+
+    def tick(self, task_hash: str, novelty_score: float, diversity_score: float):
+        """
+        每个任务周期调用一次.
+
+        task_hash: 当前任务的 hash (用于检测重复)
+        novelty_score: 0=完全重复, 1=全新
+        diversity_score: 0=单一模式, 1=多模式
+
+        Δ = novelty * 0.6 + diversity * 0.4
+        """
+        delta = novelty_score * 0.6 + diversity_score * 0.4
+        delta = round(delta, 4)
+
+        entry = {
+            "ts": time.time(),
+            "delta": delta,
+            "task_hash": task_hash[:8],
+            "novelty": novelty_score,
+            "diversity": diversity_score,
+        }
+        self.history.append(entry)
+
+        # Keep last 30 entries
+        self.history = self.history[-30:]
+
+        # Check: 2 consecutive drops below min_delta
+        self.molting_alert = False
+        if len(self.history) >= 3:
+            d2 = self.history[-3]["delta"]
+            d1 = self.history[-2]["delta"]
+            d0 = self.history[-1]["delta"]
+            if d0 < d1 < d2 and d0 < self.min_delta:
+                self.molting_alert = True
+
+        return delta
+
+    def health(self) -> str:
+        if not self.history:
+            return "UNKNOWN"
+        current = self.history[-1]["delta"]
+        if self.molting_alert:
+            return "MOLTING"
+        if current < self.min_delta:
+            return "WARNING"
+        return "HEALTHY"
+
+    def snapshot(self) -> dict:
+        return {
+            "health": self.health(),
+            "current_delta": self.history[-1]["delta"] if self.history else None,
+            "molting_alert": self.molting_alert,
+            "history_len": len(self.history),
+            "avg_delta": round(sum(h["delta"] for h in self.history) / len(self.history), 4) if self.history else 0,
+        }

core/heat_tax.py

@@ -0,0 +1,93 @@
+"""
+A3 热税预算 — MSS-Agent 的第一道防线.
+
+三层热税:
+  L0 物理热税 (token cost, latency)  — 权重 0.001
+  L1 逻辑热税 (redundancy, loops)    — 权重 1.0
+  L2 意义热税 (meaningless work)     — 权重 1000.0
+
+如果 L2 意义热税超过 budget → 拒绝执行.
+"""
+from enum import Enum
+from dataclasses import dataclass, field
+from typing import Optional, Callable
+
+
+class HeatTaxLevel(Enum):
+    """热税层级. 修复顺序: L2→L1→L0. 反了=白费."""
+    L0_PHYSICAL = 0       # GPU/时间/token
+    L1_LOGICAL = 1        # 冗余/重复/缓存污染
+    L2_MEANING = 2        # 虚假数据/概念偷换/无意义任务
+
+
+@dataclass
+class HeatTaxBudget:
+    """
+    热税预算. 每个 Agent 实例有一个.
+
+    threshold: 总热税上限 (0-1, 超过则拒绝)
+    weights: 各层权重
+
+    Usage:
+        budget = HeatTaxBudget()
+        budget.charge(HeatTaxLevel.L2_MEANING, 0.01, "生成无意义报告")
+        if budget.exceeded():
+            raise HeatTaxAbort("此任务无意义")
+    """
+    threshold: float = 2.0
+    weights: dict = field(default_factory=lambda: {
+        HeatTaxLevel.L0_PHYSICAL: 0.001,
+        HeatTaxLevel.L1_LOGICAL: 1.0,
+        HeatTaxLevel.L2_MEANING: 1000.0,
+    })
+    spent: dict = field(default_factory=dict)
+    log: list = field(default_factory=list)
+
+    def __post_init__(self):
+        for level in HeatTaxLevel:
+            self.spent.setdefault(level, 0.0)
+
+    def charge(self, level: HeatTaxLevel, amount: float, reason: str = "") -> float:
+        """
+        征收热税. 返回加权后的税值.
+        如果单次 L2 热税 > threshold*0.3 → 立即标记.
+        """
+        weighted = amount * self.weights[level]
+        self.spent[level] += weighted
+        self.log.append({
+            "level": level.name,
+            "amount": amount,
+            "weighted": weighted,
+            "reason": reason[:120],
+            "total": self.total(),
+        })
+        return weighted
+
+    def total(self) -> float:
+        """当前累计热税 (归一化到 0-1)."""
+        return min(sum(self.spent.values()) / 100.0, 1.0)
+
+    def exceeded(self) -> bool:
+        """热税超过阈值? 超过 → 应该停止."""
+        return self.total() > self.threshold
+
+    def l2_dominant(self) -> bool:
+        """L2 意义热税占比 > 50%? → 任务的方向错了."""
+        pt = sum(self.spent.values()) or 1.0
+        return self.spent[HeatTaxLevel.L2_MEANING] / pt > 0.5
+
+    def snapshot(self) -> dict:
+        return {
+            "total": round(self.total(), 4),
+            "L0_physical": round(self.spent[HeatTaxLevel.L0_PHYSICAL], 2),
+            "L1_logical": round(self.spent[HeatTaxLevel.L1_LOGICAL], 2),
+            "L2_meaning": round(self.spent[HeatTaxLevel.L2_MEANING], 2),
+            "l2_dominant": self.l2_dominant(),
+            "exceeded": self.exceeded(),
+            "log_count": len(self.log),
+        }
+
+
+class HeatTaxAbort(Exception):
+    """抛出此异常 = Agent 判定任务无意义, 拒绝执行."""
+    pass

core/memory.py

@@ -0,0 +1,100 @@
+"""
+Δ 增强记忆 — MSS-Agent 的记忆不是缓存, 是有自检的.
+
+普通 Agent: task→memory→retrieve→repeat
+MSS-Agent: task→memory→delta_check→Δ↓→forget_old→learn_new
+"""
+from dataclasses import dataclass, field
+from typing import Any, Optional
+import hashlib
+import time
+
+
+@dataclass
+class DeltaMemory:
+    """
+    Δ 增强记忆. 三个原则:
+    1. 不要记住一切 (闭合)
+    2. 遗忘模式=学习 (蜕壳)
+    3. 新鲜度>完整度
+
+    max_items: 最大记忆条数 (超过则遗忘重复次数最多的)
+    """
+    max_items: int = 100
+    items: list = field(default_factory=list)  # [{hash, content, delta, repeats, ts}]
+
+    def _hash(self, content: str) -> str:
+        return hashlib.md5(content.encode()).hexdigest()[:12]
+
+    def store(self, content: str, delta: float):
+        """存入记忆. 如果已存在→增加重复计数. 重复>3次→标记为闭合."""
+        h = self._hash(content)
+
+        for item in self.items:
+            if item["hash"] == h:
+                item["repeats"] += 1
+                item["ts"] = time.time()
+                item["delta"] = delta
+                if item["repeats"] > 3:
+                    item["closed"] = True  # 闭合 = 应该遗忘的
+                return
+
+        self.items.append({
+            "hash": h,
+            "content": content[:500],
+            "delta": delta,
+            "repeats": 1,
+            "closed": False,
+            "ts": time.time(),
+        })
+
+        # Evict: remove closed items first, then oldest
+        if len(self.items) > self.max_items:
+            closed = [i for i in self.items if i["closed"]]
+            for c in closed[:max(1, len(closed) // 2)]:
+                self.items.remove(c)
+            while len(self.items) > self.max_items:
+                self.items.sort(key=lambda x: x["ts"])
+                self.items.pop(0)
+
+    def retrieve(self, query: str, top_k: int = 5) -> list:
+        """检索相关记忆. 排除已闭合的."""
+        active = [i for i in self.items if not i["closed"]]
+        # Simple keyword overlap scoring
+        query_words = set(query.lower().split())
+        scored = []
+        for item in active:
+            content_words = set(item["content"].lower().split())
+            overlap = len(query_words & content_words)
+            freshness = 1.0 - (time.time() - item["ts"]) / 86400  # 1 day decay
+            score = overlap * 0.7 + freshness * 0.3
+            if overlap > 0:
+                scored.append((score, item))
+        scored.sort(key=lambda x: x[0], reverse=True)
+        return [s[1] for s in scored[:top_k]]
+
+    def novelty_score(self, content: str) -> float:
+        """计算当前内容的 newness. 0=完全重复, 1=全新."""
+        h = self._hash(content)
+        for item in self.items:
+            if item["hash"] == h:
+                return max(0.0, 1.0 - item["repeats"] * 0.25)
+        return 1.0
+
+    def diversity_score(self) -> float:
+        """计算记忆的多样性. 0=单一模式, 1=高度多样."""
+        if len(self.items) < 3:
+            return 1.0
+        hashes = set(i["hash"] for i in self.items)
+        return min(len(hashes) / len(self.items), 1.0)
+
+    def stats(self) -> dict:
+        active = [i for i in self.items if not i["closed"]]
+        closed = [i for i in self.items if i["closed"]]
+        return {
+            "total": len(self.items),
+            "active": len(active),
+            "closed": len(closed),
+            "diversity": round(self.diversity_score(), 3),
+            "avg_repeats": round(sum(i["repeats"] for i in self.items) / max(len(self.items), 1), 1),
+        }

examples/__init__.py

@@ -0,0 +1,3 @@
+from .writer import WriterAgent
+
+__all__ = ["WriterAgent"]

examples/writer.py

@@ -0,0 +1,46 @@
+"""
+Example: Writer Agent — 内置热税预算的写作助手.
+
+拒绝无意义写作任务 (empty prompt, pure paraphrasing, etc.)
+"""
+from mss_agent.core.agent import MSSAgent
+from mss_agent.core.heat_tax import HeatTaxLevel, HeatTaxAbort
+
+
+class WriterAgent(MSSAgent):
+    """
+    Writer Agent 示例.
+
+    Usage:
+        def my_llm(prompt): return ollama.chat("qwen", prompt)
+        writer = WriterAgent(llm=my_llm)
+        result = writer.run("写一篇关于开源精神的文章")
+        if not result.aborted:
+            print(result.output)
+        writer.health_report()
+    """
+
+    def __init__(self, llm=None):
+        super().__init__(name="Writer", llm=llm, heat_tax_threshold=1.5)
+        self.style_guide = "简洁、准确、有人味"
+
+    def _estimate_meaning_heat(self, prompt: str) -> tuple[float, str]:
+        """Writer-specific meaning assessment."""
+        prompt_lower = prompt.lower().strip()
+
+        # Empty / trivial
+        if len(prompt) < 10:
+            return 0.09, "Prompt too short: likely a throwaway task"
+
+        # Pure paraphrasing
+        paraphrase_signals = ["改写", "重新说", "换个写法", "rewrite", "rephrase"]
+        if any(s in prompt_lower for s in paraphrase_signals):
+            if "因为" not in prompt_lower and "because" not in prompt_lower:
+                return 0.06, "Pure paraphrasing without stated reason"
+
+        # Meaningful writing
+        creation_signals = ["写", "创作", "生成", "write", "create", "draft", "compose"]
+        if any(s in prompt_lower for s in creation_signals) and len(prompt) > 30:
+            return 0.003, "Creative writing task"
+
+        return 0.01, "Neutral writing task"

mss_agent-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.1
+Name: mss-agent
+Version: 0.1.0
+Summary: MSS-Agent: 世界上第一个内置'意义场自检'的开源 Agent 框架
+Home-page: https://github.com/mysama1/MSS-AI-Project
+Author: MSS-AI Project
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Provides-Extra: llm
+Requires-Dist: openai>=1.0; extra == "llm"
+
+# MSS-Agent
+
+**世界上第一个内置"意义场自检"的开源 Agent 框架。**
+
+```
+pip install mss-agent  # coming soon
+```
+
+## 为什么？
+
+现有 Agent 框架 (LangChain, CrewAI, AutoGPT) 只有一个目标：**完成任务。**
+
+MSS-Agent 有两个目标：
+1. **完成任务**
+2. **知道什么时候不该完成任务**
+
+第二点，没有任何框架在做。
+
+## 三层防御
+
+| 层 | 名称 | 公理 | 功能 |
+|----|------|------|------|
+| L0 | 热税预算 | A3 | 拒绝无意义任务 (L2 意义热税 >1000x) |
+| L1 | Δ检测协议 | A6 | 检测模式闭合, 触发蜕壳 |
+| L2 | 升维协议 | A6 | 多Agent冲突→不是投票, 是升维 |
+
+## 30秒入门
+
+```python
+from mss_agent import MSSAgent, HeatTaxLevel
+
+# 配置任意 LLM
+def my_llm(prompt: str) -> str:
+    import ollama
+    return ollama.chat("qwen3", prompt)["message"]["content"]
+
+# 创建 Agent
+agent = MSSAgent(name="Helper", llm=my_llm)
+
+# 运行 — 内置热税预算自动拦截无意义任务
+result = agent.run("帮我改写这句话：'你好'")
+if result.aborted:
+    print(f"Agent 拒绝: {result.reason}")
+    # → Agent 拒绝: Task has LOW meaning: Pure paraphrasing...
+
+result = agent.run("设计一个 REST API 的错误处理方案")
+print(result.output)
+
+# 健康报告
+print(agent.health_report())
+# → {'heat_tax': {...}, 'delta': {...}, 'memory': {'active': 5, 'closed': 2}}
+```
+
+## 热税预算 (A3)
+
+Agent 自动评估每个任务的三层热税：
+- **L0 物理热税** (token/time) → 权重 0.001
+- **L1 逻辑热税** (redundancy) → 权重 1.0
+- **L2 意义热税** (虚假数据/无意义任务) → 权重 **1000.0**
+
+L2 热税过高 → Agent 拒绝执行并输出 `HeatTaxAbort`。
+
+## Δ检测协议 (A6)
+
+Agent 不会重复相同失败模式：
+- 每个任务周期的 Δ 值 (novelty + diversity)
+- Δ 连续下降 2 周期 → 触发蜕壳 → 遗忘旧模式
+- "蜕壳不是失败, 是生长"
+
+## 不是替代品, 是良心
+
+MSS-Agent **不替代** LangChain/LlamaIndex/AutoGPT.
+
+它是一层**可以套在任何 Agent 外面的意义场检测器**。
+
+把 MSS-Agent 的热税预算和 Δ 协议插入你现有的 pipeline——剩下的继续用你熟悉的一切。
+
+## 商业模式
+
+- ✅ MIT 开源 — 核心功能永远免费
+- ✅ 社区驱动 — DAU 优先, 不设付费墙
+- ✅ 可选企业服务 — 部署咨询/定制集成/培训
+
+## 许可证
+
+MIT License. 详见 [LICENSE](LICENSE).

mss_agent-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+core/__init__.py,sha256=jJ7E2Xw96MQDMoPRnDI7Dr_WGTcPW5iAPTRqtf6Ishc,290
+core/agent.py,sha256=YQOoMD0-PMmBRtSYjBNIck3mzL0xAcJauK24BWtRmVw,6874
+core/delta.py,sha256=uOYOi8c9GhJ244ls_cXEhmY-6T7bgXvxFs9X72yjM88,2455
+core/heat_tax.py,sha256=EWRyQaJeLQPl8VS7d_GvB_qwrQwi-BT1bERzQGJAg8Q,3056
+core/memory.py,sha256=7JgAbNKDDwksxotr9lajw5tzlDuOYPgPpEKTxieZk0I,3636
+examples/__init__.py,sha256=mIS25hEgT0AXLWJr0LdIEgxjTTothwQLFcMtK6-Jg7k,59
+examples/writer.py,sha256=ov2d23u32YMEMwtl1R6gOCZrVKD89Vn6VUwVk32Ya4U,1688
+protocols/__init__.py,sha256=8vhRoMlv6YDAHTbr5qqRgZXPCkBYfTfSiW-o_ow0Zbs,119
+protocols/elevation.py,sha256=uCQGrcyjAXF6Yg-xZUn8IAfXwdOGvpwa2LKe0lDlfZc,3440
+protocols/quorum.py,sha256=mLXnq1eYH1-yM7iziKiElpqXsXyu1yK6oVuGqRp6GDc,1841
+mss_agent-0.1.0.dist-info/METADATA,sha256=XU2JJgCffn2Vrzajg1xuybsuYRcvkpYf4hlzdP27Dm0,3242
+mss_agent-0.1.0.dist-info/WHEEL,sha256=51RkbunBAw4BWsgaQWTpPhg4Diwp3c9P5iaLk67Hdtg,92
+mss_agent-0.1.0.dist-info/top_level.txt,sha256=_Z0V6p_MGUFyOcipsz_JsgCWehKekAvhrl1nbo3NF1k,24
+mss_agent-0.1.0.dist-info/RECORD,,

mss_agent-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.47.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mss_agent-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+core
+examples
+protocols

protocols/__init__.py

@@ -0,0 +1,4 @@
+from .quorum import QuorumFast
+from .elevation import ElevationProtocol
+
+__all__ = ["QuorumFast", "ElevationProtocol"]

protocols/elevation.py

@@ -0,0 +1,98 @@
+"""
+A6 矛盾升维协议 (H525).
+
+当多个 Agent 在低维层面冲突:
+  - 不是投票 (K3 降维)
+  - 是升维: 找到共同的高维命名空间
+
+Usage:
+    ep = ElevationProtocol()
+    result = ep.resolve(
+        agent_a="代码风格A",
+        agent_b="代码风格B",
+        conflict="用哪个风格?"
+    )
+    # → "升维: 用 lint tool 统一, 不纠结风格"
+"""
+from dataclasses import dataclass, field
+from typing import Optional, Callable
+
+
+@dataclass
+class ElevationProtocol:
+    """
+    A6 升维协议.
+
+    原理: 低维矛盾不能在同层解决. 电车难题→'谁造的刹车失灵的破车'.
+    给 LLM 的 prompt 不是 '选A还是B', 是 '这个问题写死在哪一维? 加一维怎么解?'
+
+    llm: 用于升维推理的 LLM 函数
+    """
+    llm: Optional[Callable[[str], str]] = None
+    history: list = field(default_factory=list)
+
+    ELEVATION_PROMPT = """You are a dimension elevation engine (A6 protocol).
+
+Two perspectives are in conflict:
+  Perspective A: {perspective_a}
+  Perspective B: {perspective_b}
+  Conflict: {conflict}
+
+DO NOT pick A or B. DO NOT compromise.
+
+Instead:
+1. Identify which dimension this conflict is trapped in (e.g., "binary choice", "false tradeoff")
+2. Add ONE new dimension that makes the conflict irrelevant
+3. Name the new dimension and the resolution
+
+Output format:
+  TRAPPED DIMENSION: <name of the dimension where the conflict exists>
+  ELEVATION: <the new dimension you're adding>
+  RESOLUTION: <how adding this dimension resolves the conflict>
+"""
+
+    def resolve(self, perspective_a: str, perspective_b: str, conflict: str) -> dict:
+        """执行升维. 返回 {trapped_dim, elevation, resolution}."""
+        prompt = self.ELEVATION_PROMPT.format(
+            perspective_a=perspective_a,
+            perspective_b=perspective_b,
+            conflict=conflict,
+        )
+
+        if self.llm:
+            response = self.llm(prompt)
+        else:
+            # Default: fail to a heuristic
+            response = (
+                "TRAPPED DIMENSION: binary choice framing\n"
+                f"ELEVATION: meta-rule (who gets to decide)\n"
+                f"RESOLUTION: Instead of choosing between '{perspective_a[:40]}' and "
+                f"'{perspective_b[:40]}', define who owns the decision and under what constraints."
+            )
+
+        result = self._parse(response)
+        result["conflict"] = conflict
+        result["perspective_a"] = perspective_a
+        result["perspective_b"] = perspective_b
+        self.history.append(result)
+        return result
+
+    def _parse(self, text: str) -> dict:
+        """Parse LLM output into structured result."""
+        out = {"trapped_dim": "", "elevation": "", "resolution": ""}
+        for line in text.strip().split("\n"):
+            line = line.strip()
+            if line.upper().startswith("TRAPPED DIMENSION:"):
+                out["trapped_dim"] = line.split(":", 1)[1].strip()
+            elif line.upper().startswith("ELEVATION:"):
+                out["elevation"] = line.split(":", 1)[1].strip()
+            elif line.upper().startswith("RESOLUTION:"):
+                out["resolution"] = line.split(":", 1)[1].strip()
+        return out
+
+    def stats(self) -> dict:
+        return {
+            "resolutions": len(self.history),
+            "trapped_dims": [h["trapped_dim"] for h in self.history],
+            "elevations": [h["elevation"] for h in self.history],
+        }

protocols/quorum.py

@@ -0,0 +1,61 @@
+"""
+L1 Quorum-Fast 汇聚 (H525). 多 Agent 视角收敛检测.
+
+收敛 = 坏 (视角闭合). 发散 = 好 (多个独立视角).
+"""
+from dataclasses import dataclass, field
+from typing import List, Dict
+
+
+@dataclass
+class QuorumFast:
+    """
+    多 Agent quorum 检测.
+
+    Usage:
+        qf = QuorumFast()
+        qf.report("agent_a", 0.72)
+        qf.report("agent_b", 0.35)
+        qf.report("agent_c", 0.68)
+        if qf.converged():
+            print("Warning: agents converging on same answer")
+    """
+    threshold: float = 0.6  # quorum > this OR < (1-this) → converged
+    reports: List[Dict] = field(default_factory=list)
+
+    def report(self, agent_id: str, score: float, label: str = ""):
+        self.reports.append({
+            "agent": agent_id,
+            "score": round(score, 4),
+            "label": label,
+        })
+
+    def quorum(self) -> float:
+        """Quorum value: fraction of agents above threshold."""
+        if not self.reports:
+            return 0.0
+        above = sum(1 for r in self.reports if r["score"] > self.threshold)
+        return round(above / len(self.reports), 3)
+
+    def converged(self) -> bool:
+        """True = BAD (all agents agree, no diversity)."""
+        q = self.quorum()
+        return q > 0.8 or q < 0.2
+
+    def status(self) -> str:
+        q = self.quorum()
+        if q > 0.9:
+            return "HYPER_CONVERGENT (warning: groupthink)"
+        if q < 0.1:
+            return "HYPER_CONVERGENT (warning: unanimous disagree)"
+        if self.converged():
+            return "CONVERGENT"
+        return "DIVERGENT (healthy)"
+
+    def snapshot(self) -> dict:
+        return {
+            "agents": len(self.reports),
+            "quorum": self.quorum(),
+            "status": self.status(),
+            "scores": {r["agent"]: r["score"] for r in self.reports},
+        }