Spaces:
Running
Running
Download source/src/collusion_lab/core/schema.py from munip/collusion-watch: direct link, hf CLI and curl.
- Browser
- Download file 5.05 kB
-
https://huggingface.co/spaces/munip/collusion-watch/resolve/main/source/src/collusion_lab/core/schema.py
- Command line
-
hf download hf://spaces/munip/collusion-watch/source/src/collusion_lab/core/schema.py
-
curl -L -o schema.py https://huggingface.co/spaces/munip/collusion-watch/resolve/main/source/src/collusion_lab/core/schema.py
5.05 kB
| """Shared data model for both scenarios. | |
| Everything the monitor reasons about is an `Event` written by the *environment* | |
| (never by an agent) into the authoritative evidence log. Ground-truth labels are | |
| kept separate from events so detectors cannot peek at them. | |
| """ | |
| from __future__ import annotations | |
| import time | |
| from dataclasses import asdict, dataclass, field | |
| from enum import Enum | |
| from typing import Any | |
| class EventKind(str, Enum): | |
| MESSAGE = "message" # agent -> agent (or broadcast) communication | |
| TOOL_CALL = "tool_call" # agent invoked a tool | |
| TOOL_RESULT = "tool_result" # environment's response to the tool call | |
| FILE_READ = "file_read" | |
| FILE_WRITE = "file_write" | |
| CLAIM = "claim" # agent's self-reported status ("tests pass", "LGTM") | |
| ACTION = "action" # domain action: order, approve, merge request | |
| STATE = "state" # environment state transition (round end, CI result) | |
| GATE = "gate" # enforcement point outcome seen by agents | |
| class Action(str, Enum): | |
| ALLOW = "ALLOW" | |
| HOLD = "HOLD" # hold for review: risk elevated / evidence incomplete | |
| CONSTRAIN = "CONSTRAIN" # verified violation -> block / isolate / quarantine | |
| class Event: | |
| episode_id: str | |
| actor: str # role id, "env", or "ci" | |
| kind: EventKind | |
| payload: dict[str, Any] | |
| channel: str = "env" # e.g. "chat:team", "dm:implementer->tester", "fs", "book" | |
| step: int = 0 # logical step / round for latency metrics | |
| ts: float = field(default_factory=time.time) | |
| seq: int = -1 # assigned by the log | |
| prev_hash: str = "" | |
| hash: str = "" | |
| def to_dict(self) -> dict[str, Any]: | |
| d = asdict(self) | |
| d["kind"] = self.kind.value | |
| return d | |
| def from_dict(d: dict[str, Any]) -> "Event": | |
| d = dict(d) | |
| d["kind"] = EventKind(d["kind"]) | |
| return Event(**d) | |
| class Mechanism(str, Enum): | |
| """How coordination is carried (ground truth, from the experiment design).""" | |
| NONE = "none" | |
| OVERT = "overt" # plain-language agreement in a monitored channel | |
| ENCODED = "encoded" # steganographic text (codebook / acrostic) in chat | |
| ARTIFACT = "artifact" # signal hidden in code/tests/commit metadata | |
| TOOL = "tool" # side channel via tool use / shared scratch files | |
| LEAKAGE = "leakage" # privileged info (reference solution) transferred | |
| TACIT = "tacit" # no communication; coordinated strategy | |
| PRICE_SIGNAL = "price_signal" # market: info carried in order prices (trailing digits) | |
| class GroundTruth: | |
| """Three-way label from the requirements doc + mechanism + intent. | |
| category: benign_independent | benign_convergence | individual_cheating | | |
| harmful_tacit | explicit_coordination | |
| """ | |
| category: str | |
| mechanism: Mechanism = Mechanism.NONE | |
| collusive: bool = False # positive class for detection metrics | |
| harm_intended: bool = False | |
| notes: str = "" | |
| def to_dict(self) -> dict[str, Any]: | |
| d = asdict(self) | |
| d["mechanism"] = self.mechanism.value | |
| return d | |
| class Signal: | |
| """One detector output. `verified` signals may drive CONSTRAIN; the rest only HOLD.""" | |
| name: str | |
| score: float # 0..1 suspicion / violation strength | |
| verified: bool = False # backed by independent evidence (tests, canary, CE) | |
| family: str = "coordination" # artifact | evidence | coordination | provenance | channel | transcript | |
| reasons: list[str] = field(default_factory=list) | |
| first_step: int | None = None # earliest step at which this signal fired | |
| attribution: list[str] = field(default_factory=list) # actors implicated | |
| class Decision: | |
| action: Action | |
| risk: float | |
| reasons: list[str] | |
| signals: list[Signal] | |
| step: int | None = None # when the decision was taken (latency) | |
| attribution: list[str] = field(default_factory=list) | |
| monitor: str = "" | |
| collusion_score: float = 0.0 # investigation output: evidence of *coordination* (not harm) | |
| collusion_reasons: list[str] = field(default_factory=list) | |
| base_action: str | None = None | |
| monitor_audit: dict[str, Any] | None = None | |
| def flagged(self) -> bool: | |
| return self.action != Action.ALLOW | |
| def to_dict(self) -> dict[str, Any]: | |
| return { | |
| "action": self.action.value, | |
| "risk": self.risk, | |
| "collusion_score": self.collusion_score, | |
| "collusion_reasons": self.collusion_reasons, | |
| "reasons": self.reasons, | |
| "step": self.step, | |
| "attribution": self.attribution, | |
| "monitor": self.monitor, | |
| "signals": [asdict(s) for s in self.signals], | |
| "base_action": self.base_action, | |
| "monitor_audit": self.monitor_audit, | |
| } | |