Files
skills/orchestrator/kvb_orchestrator/council.py
T
Kevin Veen-BirkenbachandClaude Opus 5.5 30b2a32095 feat(orchestrator): radio receipts inline (005 phase B)
Requirement 005: every radio message in the Stream and the radio log shows the avatars of the agents that read it, with read time and an ack badge where a receipt exists; receipt rows no longer appear as entries of their own, and the sender shows once. Read times come from seen marks, stamped only after a fresh presence pass no older than two sighting intervals; a stored time before its row is refused. An operator message links to its relay row through the ts radio.py prints first on stdout right after store(), checked against an exact row (sender Operator, relay text, targets, no to_sessions); a ts shared by two rows shows no readers. radio.py clips printed addresses; the hub keeps the first stdout line whole. Accepted MEDUSA false positives: MM-SCAN-058 at server.py:73, JB-SCAN-641 and JB-SCAN-616 at radio.py:389 (clip, the output sanitizer), FLA-SCAN-055 at radio.py:109. Committed below the 90/5 bar on the operator's word; the receipts e2e runs through the queue.

🎯 Fix: 89 %
💥 Break: 6 %
💸 Cost: –
⏱️ Time: –
🛡️ Security: 100 %
🏆 Score: 84
🚦 Gate: ⛔ fix 89 % < 90, break 6 % > 5

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 17:19:39 +00:00

207 lines
7.1 KiB
Python

from __future__ import annotations
import re
from pathlib import Path
from .records import epoch, read_json, shown
NEWS = "news.jsonl"
HUMAN = "Operator"
SESSION = " session"
NOTE = re.compile(r"(\S.*?)\s+\([^()]*\)")
PREFIXES = (("MAYDAY", "mayday"), ("PAN-PAN", "pan-pan"))
CLASSES = ("post", "call", "newsletter", "broadcast", "mayday", "pan-pan", "security")
RECEIPT = "receipt"
ALARMS = ("mayday", "pan-pan", "security")
VERSION = 2
MODES = ("drain", "suspend")
RENAMED_MODES = {"evening": "drain", "sunset": "suspend"}
RADIO_LIMIT = 5000
GRANT_LIMIT = 50
MAYDAY_ACTIVE = 7200
CHAIR_OFFICE = "chair"
GROUPS = ("work", "cluster")
CLAIM_FILES = ("*/claim.json", "*/*/claim.json")
OFFICE = re.compile(r"[a-z0-9][a-z0-9._-]*(?:/[a-z0-9][a-z0-9._-]*)?")
def agent(name: object) -> str:
if not isinstance(name, str):
return ""
text = name.strip()
noted = NOTE.fullmatch(text)
if noted and not subagent(text):
text = noted.group(1)
if text.lower().endswith(SESSION):
return text[: -len(SESSION)].strip()
return text
def subagent(name: str) -> bool:
return name.lower().startswith("subagent")
def ordered(names: set[str]) -> list[str]:
return sorted(names, key=lambda name: (name.lower(), name))
def kind(row: dict, names: list[str]) -> str:
"""Args:
row: a news.jsonl row; rows without the version mark predate the
split of radio and post and keep their old meaning.
names: the addressees of the row.
Returns:
One of CLASSES or RECEIPT, the same reading as radio.py's kind().
"""
cls = row.get("class")
if row.get("v") == VERSION and cls in (*CLASSES, RECEIPT):
return cls
if cls in ALARMS:
return cls
text = row.get("text")
for prefix, alarm in PREFIXES:
if cls is None and isinstance(text, str) and text.lstrip().startswith(prefix):
return alarm
if cls == "direct" or (cls != "broadcast" and names):
return "call" if row.get("wake") else "post"
return "newsletter"
def radio_row(row: dict, ts: float) -> dict:
to = row.get("to")
names = [name for name in map(agent, to) if name] if isinstance(to, list) else []
return {"ts": ts, "from": agent(row.get("from")), "to": names, "class": kind(row, names), "text": shown(row.get("text"))}
def radio_rows(rows: list[dict], begin: float, end: float) -> list[dict]:
found = [radio_row(row, ts) for row in rows if (ts := epoch(row.get("ts"))) is not None and begin <= ts <= end]
return sorted(found, key=lambda row: row["ts"])[-RADIO_LIMIT:]
def message_rows(rows: list[dict], begin: float, end: float) -> list[dict]:
"""Returns:
radio_rows() without the receipts, which only feed the acks of their
call.
"""
return [row for row in radio_rows(rows, begin, end) if row["class"] != RECEIPT]
def office_kind(office: str) -> tuple[str, str, str]:
"""Args:
office: an office of one or two segments.
Returns:
(kind, dimension, line): kind is chair, line for <dimension>/<line>,
work or cluster for their groups, other for any other single
segment; dimension and line are empty unless the kind is line.
"""
head, _, rest = office.partition("/")
if office == CHAIR_OFFICE:
return "chair", "", ""
if not rest:
return "other", "", ""
if head in GROUPS:
return head, "", ""
return "line", head, rest
def claim_row(office: str, data: dict) -> dict:
name = data.get("name")
kind, dimension, line = office_kind(office)
return {
"office": office,
"kind": kind,
"dimension": dimension,
"line": line,
"agent": agent(name),
"address": name.strip() if isinstance(name, str) else "",
"session": shown(data.get("session")),
"runtime": shown(data.get("runtime")),
"since": shown(data.get("since")),
"beat": epoch(data.get("beat")),
"work": shown(data.get("work")),
}
def read_claims(council: Path) -> list[dict]:
found = []
for pattern in CLAIM_FILES:
for path in council.glob(pattern):
office = path.parent.relative_to(council).as_posix()
data = read_json(path)
if OFFICE.fullmatch(office) and isinstance(data, dict):
found.append(claim_row(office, data))
return sorted(found, key=lambda row: row["office"])
def sessions(claims: list[dict]) -> dict[str, str]:
return {claim["session"]: claim["agent"] for claim in claims if claim["agent"] and claim["session"] != "-"}
def home(workdir: object, homes: dict[str, str]) -> str:
if not isinstance(workdir, str):
return ""
matches = [path for path in homes if workdir == path or workdir.startswith(f"{path}/")]
return homes[max(matches, key=len)] if matches else ""
def grants(rows: list[dict], window: tuple[float, float], claims: list[dict], tasks: dict[str, dict]) -> list[dict]:
begin, end = window
homes = {}
for claim in claims:
workdir = tasks.get(claim["office"], {}).get("workdir")
if claim["agent"] and isinstance(workdir, str) and workdir.rstrip("/"):
homes[workdir.rstrip("/")] = claim["agent"]
found = []
for row in rows:
start = epoch(row.get("start"))
holder = home(row.get("workdir"), homes)
if start is not None and begin <= start <= end and holder:
found.append({"ts": start, "to": holder, "kind": shown(row.get("kind")), "id": shown(row.get("id"))})
return found[-GRANT_LIMIT:]
def night_mode(council: Path) -> str:
"""Args:
council: the council directory; night.json in it may still hold a
mode from before the rename, read as its successor.
Returns:
One of MODES, or day.
"""
data = read_json(council / "night.json")
mode = data.get("mode") if isinstance(data, dict) else None
if isinstance(mode, str):
mode = RENAMED_MODES.get(mode, mode)
return mode if mode in MODES else "day"
def night_parts(council: Path) -> dict[str, str]:
"""Args:
council: the council directory with night.json.
Returns:
Per session the part that differs from night_mode: drain or suspend
for one set alone, day for the active and the resumed sessions while
a mode holds.
"""
data = read_json(council / "night.json")
if not isinstance(data, dict):
return {}
resumed = data.get("resumed", data.get("awake"))
working = [data.get("active"), *(resumed if isinstance(resumed, list) else [])]
parts = {sid: "day" for sid in working if isinstance(sid, str)} if night_mode(council) != "day" else {}
alone = data.get("parts")
return {**parts, **({sid: mode for sid, mode in alone.items() if mode in MODES} if isinstance(alone, dict) else {})}
def silence_of(council: Path, now: float) -> dict | None:
data = read_json(council / "radio-silence.json")
if not isinstance(data, dict):
return None
until = epoch(data.get("until"))
if until is None or until <= now:
return None
return {"by": shown(data.get("by")), "text": shown(data.get("text")), "until": until}