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>
119 lines
7.6 KiB
Python
119 lines
7.6 KiB
Python
from __future__ import annotations
|
|
|
|
import time
|
|
|
|
from .asking import ask_state
|
|
from .council import MAYDAY_ACTIVE, NEWS, message_rows, read_claims, sessions
|
|
from .crons import cron_event
|
|
from .errors import Missing, ToolError
|
|
from .events import event, event_filters, wanted
|
|
from .fields import instant, single, whole
|
|
from .names import Directory
|
|
from .receipts import read_of
|
|
from .records import iso_epoch, read_jsonl
|
|
from .register import REGISTER, operator_rows, read_register
|
|
from .signed import signing
|
|
from .transcripts import STREAM_CUT, STREAM_KINDS, matches
|
|
|
|
STREAM_LIMIT = 2000
|
|
EVENT_LIMIT = 3000
|
|
|
|
|
|
class Timeline:
|
|
def stream(self, query: dict[str, list[str]]) -> dict:
|
|
self.transcripts.refresh()
|
|
names = sessions(read_claims(self.council))
|
|
wanted = single(query, "kind")
|
|
kinds = None if not wanted else set(wanted.split(","))
|
|
if kinds is not None and not kinds <= set(STREAM_KINDS):
|
|
raise ToolError(f"kind must be a comma list of {', '.join(STREAM_KINDS)}")
|
|
filters = {
|
|
"agent": single(query, "agent") or "",
|
|
"session": single(query, "session") or "",
|
|
"kinds": kinds,
|
|
"q": (single(query, "q") or "").lower(),
|
|
"begin": instant(query, "from"),
|
|
"end": instant(query, "to"),
|
|
}
|
|
limit = min(whole(query, "limit") or STREAM_LIMIT, STREAM_LIMIT)
|
|
picked = [
|
|
{**entry, "agent": names.get(entry["session"], ""), "text": entry["text"][:STREAM_CUT], "truncated": len(entry["text"]) > STREAM_CUT}
|
|
for entry in self.transcripts.since(whole(query, "after") or 0)
|
|
if matches(entry, names.get(entry["session"], ""), filters)
|
|
]
|
|
picked.sort(key=lambda entry: (entry["ts"], entry["id"]))
|
|
return {"entries": picked[-limit:], "last": self.transcripts.last(), "sessions": names}
|
|
|
|
def entry(self, entry_id: int) -> dict:
|
|
record = self.transcripts.entry(entry_id)
|
|
if record is None:
|
|
raise Missing(str(entry_id))
|
|
return {"id": record["id"], "text": record["text"]}
|
|
|
|
def timeline(self, begin: float, end: float, now: float, tasks: dict[str, dict], claims: list[dict], radio: list[dict], directory: Directory) -> list[dict]:
|
|
rows = []
|
|
inlined = self.inlined(radio, (begin, end), now)
|
|
for index, row in enumerate(message_rows(radio, begin, end)):
|
|
alarm = row["class"] in ("mayday", "pan-pan") and row["ts"] >= end - MAYDAY_ACTIVE
|
|
title = f"{row['from'] or '?'} → {', '.join(row['to']) or 'all'}"
|
|
source = directory.key(row["from"], row["ts"])
|
|
who = {"agent": directory.at(source, row["ts"]) or row["from"], "now": directory.now(source), "session": source}
|
|
read = read_of(inlined, row["ts"])
|
|
ref = {"to": row["to"], "class": row["class"], "targets": [directory.key(name, row["ts"]) for name in row["to"]], **read}
|
|
rows.append(event({"id": f"radio:{row['ts']}:{index}", "ts": row["ts"], "kind": "radio", "part": row["class"], **who, "title": title, "text": row["text"], "waiting": alarm, "ref": ref}))
|
|
for review in self.reviews.listed():
|
|
created = iso_epoch(review["created"]) or now
|
|
if created <= end and (review["status"] == "pending" or created >= begin):
|
|
ref = {key: review.get(key, "") for key in ("id", "status", "gate", "score", "branch", "worktree", "tree", "files")}
|
|
rows.append(event({"id": f"review:{review['id']}", "ts": created, "kind": "review", "title": review["title"], "text": review["notes"][:STREAM_CUT], "waiting": review["status"] == "pending", "ref": ref}))
|
|
for ask in self.asks.listed():
|
|
state = ask_state(ask, now)
|
|
if ask["created_ts"] <= end and (state["status"] == "pending" or ask["created_ts"] >= begin):
|
|
ref = {"id": ask["id"], "status": state["status"], "cwd": ask["cwd"], "tool": ask["tool"], "warnings": signing.warnings(ask["command"])}
|
|
who = {"agent": directory.at(ask["session"], ask["created_ts"]), "now": directory.now(ask["session"]), "session": ask["session"]}
|
|
rows.append(event({"id": f"ask:{ask['id']}", "ts": ask["created_ts"], "kind": "ask", **who, "title": ask["tool"], "text": ask["command"], "waiting": state["status"] == "pending", "ref": ref}))
|
|
for decision in self.decisions.listed():
|
|
if decision["created_ts"] <= end and (decision["status"] == "pending" or decision["created_ts"] >= begin):
|
|
ref = {key: decision.get(key, "") for key in ("id", "status", "choice", "recommended", "options")}
|
|
text = " · ".join(option["label"] for option in decision["options"])
|
|
source = directory.key(decision["agent"], decision["created_ts"])
|
|
who = {"agent": directory.at(source, decision["created_ts"]) or decision["agent"], "now": directory.now(source), "session": source}
|
|
rows.append(event({"id": f"decision:{decision['id']}", "ts": decision["created_ts"], "kind": "decision", **who, "title": decision["question"][:300], "text": text, "waiting": decision["status"] == "pending", "ref": ref}))
|
|
held = self.open_jobs()
|
|
for row in operator_rows(tasks):
|
|
first = self.watch.first(row["task"], now)
|
|
if first <= end:
|
|
ref = {key: row[key] for key in ("task", "directory", "check", "status")}
|
|
rows.append(event({"id": f"operator:{row['task']}", "ts": first, "kind": "operator", "title": row["command"], "text": row["why"], "waiting": row["task"] not in held, "ref": ref}))
|
|
rows += [change for change in self.watch.listed() if begin <= change["ts"] <= end]
|
|
rows += [cron_event(cron, directory) for cron in self.schedules(claims, now) if cron["created"] <= end and (cron["active"] or cron["created"] >= begin)]
|
|
rows += [row for row in self.log.listed() if begin <= row["ts"] <= end]
|
|
rows += directory.renames(begin, end)
|
|
return sorted(rows, key=lambda row: (row["ts"], row["id"]))
|
|
|
|
def events(self, query: dict[str, list[str]]) -> dict:
|
|
now = time.time()
|
|
begin, end = self.span(query, now)
|
|
filters = event_filters(query)
|
|
limit = min(whole(query, "limit") or EVENT_LIMIT, EVENT_LIMIT)
|
|
after = whole(query, "after") or 0
|
|
self.transcripts.refresh()
|
|
claims = read_claims(self.council)
|
|
news = read_jsonl(self.council / NEWS)
|
|
directory = self.directory(claims, news, now)
|
|
filters["aliases"] = directory.aliases(filters["agent"]) if filters["agent"] else set()
|
|
tasks = read_register(self.council / REGISTER)
|
|
self.watch.see(tasks, now)
|
|
rows = [row for row in self.timeline(begin, end, now, tasks, claims, news, directory) if wanted(row, filters)]
|
|
live = instant(query, "to") is None
|
|
entries = []
|
|
for entry in self.transcripts.since(after) if "transcript" in filters["kinds"] else []:
|
|
shaped = event({
|
|
"id": f"transcript:{entry['id']}", "ts": entry["ts"], "kind": "transcript", "part": entry["kind"], "agent": directory.at(entry["session"], entry["ts"]),
|
|
"now": directory.now(entry["session"]), "session": entry["session"], "sub": entry["sub"], "title": entry["kind"], "text": entry["text"][:STREAM_CUT],
|
|
"ref": {"entry": entry["id"], "truncated": len(entry["text"]) > STREAM_CUT},
|
|
})
|
|
if entry["ts"] >= begin and (live or entry["ts"] <= end) and wanted(shaped, filters):
|
|
entries.append(shaped)
|
|
return {"events": rows[-limit:], "entries": entries[-limit:], "last": self.transcripts.last(), "sessions": sessions(claims)}
|