Files
skills/orchestrator/kvb_orchestrator/presence.py
T
Kevin Veen-BirkenbachandClaude Opus 5.5 7d70e07b4c feat(operator): report each operator row outcome back to the agent that queued it
operator.py stores the adding session's name and id with the row. Done,
cancel and failure go to that stored name and pinned session id, never
re-resolved: a radio post by default, a call when that session picked it
with radio.py feedback set call. The caller's own parts are dropped. The
hub counts unanswered calls per session id.

MEDUSA: 34 findings accepted after an independent review, 0 true
positives: 3x CGS-SCAN-029 by design (operator-confirmed runner in
operator.py execute and its call), 2x CGS-SCAN-030 (exec inside the name
execute), CODEGEN-SCAN-003 and CGS-SCAN-028 (open inside Popen),
3x CGS-SCAN-040 (prompt loops end), 4x GENAI-SCAN-1270 (rasci.database()
JSON register), 20x FLA-SCAN-055 (dba inside the word feedback).

🎯 Fix: 93 %
💥 Break: 4 %
💸 Cost: 100 %
⏱️ Time: 100 %
🛡️ Security: 100 %
🏆 Score: 89
🚦 Gate: ✅ 90/5, cost and time <= 100, security 100 %

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 06:42:51 +00:00

94 lines
4.0 KiB
Python

from __future__ import annotations
from pathlib import Path
from .council import HUMAN, MODES, agent
from .records import epoch, read_json
STATES = ("sleeping", "suspending", "alive", "working", "dead", "unreachable")
STALE = 15 * 60
UNANSWERED = 10 * 60
SNAPSHOT = "agent-sessions.json"
SNAPSHOT_STALE = 5 * 60
def read_snapshot(path: Path, now: float) -> dict[str, dict]:
"""Args:
path: the snapshot client/sessions.py writes on the host.
now: the moment to judge at.
Returns:
Its session records by session id; empty when it is missing,
malformed, written more than SNAPSHOT_STALE ago or dated in the
future.
"""
data = read_json(path)
if not isinstance(data, dict) or not isinstance(data.get("sessions"), dict):
return {}
written = data.get("written")
if isinstance(written, bool) or not isinstance(written, int | float) or not 0 <= now - written <= SNAPSHOT_STALE:
return {}
return {sid: record for sid, record in data["sessions"].items() if isinstance(record, dict)}
def unanswered(news: list[dict], now: float) -> list[tuple[str, float]]:
"""Returns:
(callee, call time) of every call older than UNANSWERED without a
receipt: one per session id in `to_sessions`, answered by any
receipt of that call; else one per name in `to`.
"""
receipts = {(agent(row.get("from")), round(epoch(row.get("call")) or 0, 3)) for row in news if row.get("class") == "receipt"}
answered = {call for _, call in receipts}
late = []
for row in news:
ts = epoch(row.get("ts"))
if row.get("class") != "call" or ts is None or now - ts < UNANSWERED or not isinstance(row.get("to"), list):
continue
sessions = [sid for sid in row["to_sessions"] if isinstance(sid, str)] if isinstance(row.get("to_sessions"), list) else []
if sessions:
late += [(sid, ts) for sid in sessions if round(ts, 3) not in answered]
continue
late += [(name, ts) for name in map(agent, row["to"]) if name and (name, round(ts, 3)) not in receipts]
return late
def presence(sessions: dict[str, dict], parts: dict[str, str], mode: str, claims: list[dict], news: list[dict], now: float) -> dict[str, str]:
"""Args:
sessions: the session records of read_snapshot; running says
whether a record's process still runs.
parts: night_parts, a session's own part over the mode.
mode: night_mode, drain, suspend or day.
claims: the council claims; a session without a record shows alive
or dead by its freshest beat.
news: the radio rows, for calls without a receipt.
now: the moment to judge at.
Returns:
One of STATES per session id (decision 61).
"""
late = unanswered(news, now)
beats: dict[str, list[float]] = {}
names: dict[str, set[str]] = {}
for claim in claims:
if claim["session"] != "-" and claim["agent"] != HUMAN:
beats.setdefault(claim["session"], []).append(claim["beat"] or 0)
names.setdefault(claim["session"], set()).add(claim["agent"])
states = {sid: "alive" if now - max(beat) < STALE else "dead" for sid, beat in beats.items() if sid not in sessions}
for sid, record in sessions.items():
if record.get("running") is not True:
states[sid] = "dead"
continue
busy = record.get("status") == "busy"
stamp = record.get("statusUpdatedAt")
updated = (epoch(stamp / 1000) if isinstance(stamp, int | float) and not isinstance(stamp, bool) else None) or 0
called = names.get(sid, set()) | {agent(record.get("name")), sid}
if (busy and now - updated > STALE) or any(name in called and ts > updated for name, ts in late):
states[sid] = "unreachable"
continue
part = parts.get(sid, mode)
if part in MODES:
states[sid] = "suspending" if busy else "sleeping"
else:
states[sid] = "working" if busy else "alive"
return states