Files
skills/tests/test_hub_state.py
T
Kevin Veen-BirkenbachandClaude Opus 5.5 a438a2f54e feat(orchestrator): speak into every text field of the hub (requirement 013)
Requirement 013 and its implementation: page-mic.js puts a microphone on every textarea and text input, records with MediaRecorder and inserts the transcript at the cursor; Escape cancels. /api/stt transcribes with the local whisper.cpp model ggml-small-q8_0 (pinned to commit 5359861c and its sha256) in a per-request temp dir, capped at 60 s and 5 MiB, and returns German or English only, retranscribing a clip detected as another language in both and keeping the surer one. Without a model the button is disabled and names the install row. Tests run once on unify/skills-20261114 after the merge (operator order 2026-11-14).

🎯 Fix: 72 %
💥 Break: 12 %
💸 Tokens: –
⏱️ Velocity: –
🛡️ Security: 100 %
🏆 Score: 63
🚦 Gate: ⛔ fix 72 % < 90, break 12 % > 5

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 21:37:26 +00:00

230 lines
15 KiB
Python

from __future__ import annotations
import json
import time
import unittest
from unittest import mock
from hub_case import HubCase
from hub_engines import OPERATOR_VOICE, VOICES
from hub_support import ASK
from kvb_orchestrator import council, engines, exchange, phrasing, view
class TestHubState(HubCase):
def test_state_follows_the_time_window(self):
now = time.time()
self.write_council({"news.jsonl": self.jsonl([
{"ts": now - 10800, "from": "Old", "to": [], "text": "three hours"},
{"ts": now - 3600, "from": "Skills", "to": ["Docs"], "text": "one hour"},
{"ts": now - 60, "from": "Docs", "to": [], "text": "a minute"},
])})
self.request("feat: fresh", "")
self.create_ask(ASK)
default = self.snapshot()
self.assertEqual([row["text"] for row in default["radio"]], ["three hours", "one hour", "a minute"])
self.assertAlmostEqual(default["first"], now - 10800, delta=1)
status, _, body = self.get(f"/api/state?from={now - 7200}&to={now - 1800}")
self.assertEqual(status, 200, body)
past = json.loads(body)
self.assertEqual([row["text"] for row in past["radio"]], ["one hour"])
self.assertEqual((past["since"], past["until"]), (now - 7200, now - 1800))
self.assertEqual((past["reviews"], past["asks"]), ([], []))
self.assertEqual({(edge["source"], edge["target"]) for edge in past["graph"]["edges"]}, {("name:Skills", "name:Docs")})
future = json.loads(self.get(f"/api/state?from=0&to={now + 86400}")[2])
self.assertLessEqual(future["until"], time.time())
self.assertEqual(len(future["radio"]), 3)
for query in (f"from={now}&to={now - 60}", "from=soon", "to=-1", "from=1&from=2", "from=nan"):
with self.subTest(query=query):
self.assertEqual(self.get(f"/api/state?{query}")[0], 400)
def test_get_never_changes_state(self):
review_id = self.request("feat: read only", "")
before = (self.state / "reviews.json").read_bytes()
for path, expected in (
("/", 200),
("/?approve=1", 200),
("/api/state", 200),
(f"/reviews/{review_id}/page", 200),
(f"/reviews/{review_id}/files", 200),
("/reviews/0123456789abcdef/files", 404),
(f"/reviews/{review_id}/approve", 405),
(f"/reviews/{review_id}/reject", 405),
(f"/api/reviews/{review_id}", 200),
("/api/reviews/0123456789abcdef", 404),
("/api/sign", 405),
("/api/rules/sign", 405),
("/mcp", 405),
("/api/tts", 405),
("/api/stt", 405),
("/reviews/0123456789abcdef/page", 404),
("/nope", 404),
):
with self.subTest(path=path):
status, _, _ = self.call("GET", path, None, self.guard(self.host))
self.assertEqual(status, expected)
self.assertEqual(self.call("GET", "/", None, {"Host": "evil.example"})[0], 403)
self.assertEqual((self.state / "reviews.json").read_bytes(), before)
self.assertEqual(self.status(review_id), "pending")
def test_state_is_empty_without_council_files(self):
empty = {"reviews": [], "operator": [], "register": [], "radio": [], "claims": [], "grants": [], "agent_order": []}
state = self.snapshot()
self.assertEqual({key: state[key] for key in empty}, empty)
self.assertEqual([(node["id"], node["kind"]) for node in state["graph"]["nodes"]], [("Operator", "operator")])
self.assertEqual(state["graph"]["edges"], [])
self.index()
self.write_council({"rasci.json": "{not json", "queue-history.jsonl": "[" * 100000 + "\n", "work/x/claim.json": "[1]"})
(self.council / "news.jsonl").write_bytes(b"\xff\xfe" + b"[" * 100000 + b"\n")
state = self.snapshot()
self.assertEqual({key: state[key] for key in empty}, empty)
self.write_council({"rasci.json": "[1, 2]", "news.jsonl": "[" * 100000 + "\n"})
self.assertEqual(self.snapshot()["radio"], [])
self.index()
def test_state_filters_the_register_and_bounds_the_radio(self):
register = {
"operator/push-skills": {"title": "git-sign-push", "workdir": "/repo", "description": "needs the key", "check": "pushed", "status": "queued", "roles": {"Operator": "R", "One": "A"}},
"operator/old": {"title": "old command", "status": "done", "roles": {}},
"work/hub": {"title": "Build the hub", "status": "running", "worker": "One", "objective": "Reviews in the browser", "roles": {"One": "RA", "Two": "C"}, "key_results": [{"text": "a", "met": True}, {"text": "b", "met": False}]},
"work/finished": {"title": "Finished work", "status": "done", "roles": {}},
"work/stopped": {"title": "Stopped work", "status": "stopped", "roles": {}},
"work/bare": {"roles": {"Two": "R"}},
"broken": "not a row",
}
now = time.time()
rows = [{"ts": now - 100 + n, "from": "One", "to": [], "text": f"item {n:02d}"} for n in range(34)]
rows.append({"ts": now, "from": "Two", "to": [], "text": "disk full", "class": "mayday"})
lines = [json.dumps(row) for row in rows[:20]] + ["not json", json.dumps({"text": "no ts"})] + [json.dumps(row) for row in rows[20:]]
self.write_council({"rasci.json": register, "news.jsonl": "\n".join(lines) + "\n"})
with mock.patch.object(council, "RADIO_LIMIT", 30):
state = self.snapshot()
operator = state["operator"]
self.assertEqual([(row["task"], row["command"], row["why"], row["status"]) for row in operator], [("operator/push-skills", "git-sign-push", "needs the key", "queued")])
self.assertEqual([row["task"] for row in state["register"]], ["work/bare", "work/hub"])
hub = state["register"][1]
self.assertEqual((hub["title"], hub["responsible"], hub["accountable"], hub["met"], hub["total"]), ("Build the hub", "One", "One", 1, 2))
self.assertEqual(state["register"][0]["status"], "queued")
texts = [row["text"] for row in state["radio"]]
self.assertEqual(len(texts), 30)
self.assertEqual((texts[0], texts[-2], texts[-1]), ("item 05", "item 33", "disk full"))
self.assertEqual(state["radio"][-1]["class"], "mayday")
def test_state_collects_radio_claims_grants_and_the_graph(self):
now = time.time()
register = {
"operator/push": {"title": "git-sign-push", "workdir": "/repo", "status": "blocked", "roles": {"Operator": "R", "Skills session": "A"}},
"work/hub": {"title": "Build the hub", "status": "running", "worker": "Skills session", "workdir": "/repo/.worktrees/hub", "roles": {"Skills session": "R", "Maintainer": "A"}},
"work/sub": {"title": "Helper", "status": "running", "worker": "subagent general-purpose (default)", "roles": {"Skills": "A"}},
"work/old": {"title": "Old", "status": "done", "worker": "Ghost session", "roles": {}},
}
news = [
{"ts": now - 50, "from": "Skills session", "to": ["Maintainer"], "text": "ready"},
{"ts": now - 40, "from": "Skills", "to": ["Maintainer"], "text": "again", "class": "direct"},
{"ts": now - 30, "from": "Maintainer", "to": [], "text": "board"},
{"ts": now - 20, "from": "Docs", "to": [], "text": "MAYDAY disk full"},
{"ts": now - 10, "from": "Docs", "to": ["Skills"], "text": "PAN-PAN slow"},
{"ts": now - 5, "from": "Maintainer", "to": ["Skills", "Docs"], "text": "rotate", "class": "security"},
{"ts": now - 2 * 86400, "from": "Old", "to": [], "text": "too old"},
]
claim = {"office": "work/hub", "session": "s1", "runtime": "claude", "name": "Skills", "since": "2026-11-05T10:00:00+00:00", "beat": now, "work": "build the hub"}
gate = {"office": "cluster/gate", "session": "s2", "runtime": "codex", "name": "Gatekeeper", "since": "2026-11-05T09:00:00+00:00", "beat": now, "work": "gate"}
chair = {"office": "chair", "session": "s3", "runtime": "claude-code", "name": "Maintainer", "since": "2026-11-05T08:00:00+00:00", "beat": now, "work": "allocate"}
line = {"office": "identity/oidc", "session": "s1", "runtime": "claude", "name": "Skills", "since": "2026-11-05T10:00:00+00:00", "beat": now, "work": "oidc line"}
history = [
{"id": "q1", "kind": "gate", "signature": "make test", "workdir": "/repo/.worktrees/hub/sub", "start": now - 15, "end": now - 5, "exit": 0, "minutes": 0.2},
{"id": "q2", "kind": "deploy", "signature": "make deploy", "workdir": "/elsewhere", "start": now - 15, "end": now - 5, "exit": 0, "minutes": 0.2},
{"id": "q3", "kind": "gate", "signature": "make test", "workdir": "/repo/.worktrees/hub", "start": now - 2 * 86400, "end": now - 2 * 86400 + 60, "exit": 0, "minutes": 1},
]
self.write_council({
"rasci.json": register,
"news.jsonl": self.jsonl(news),
"work/hub/claim.json": claim,
"cluster/gate/claim.json": gate,
"chair/claim.json": chair,
"identity/oidc/claim.json": line,
"work/broken/claim.json": "not json",
"queue-history.jsonl": self.jsonl(history),
})
state = self.snapshot()
self.assertEqual(
set(state),
{
"now", "since", "until", "first", "alarm_since", "reviews", "asks", "decisions", "messages", "operator",
"register", "tasks", "task_edges", "queue_line", "agent_order", "radio", "claims", "grants", "night", "night_parts", "presence", "silence", "graph",
"inbox", "pending", "rules", "approvers", "jobs", "views", "llm", "people", "settings", "media", "speech",
"badges", "kinds",
},
)
self.assertEqual([row["speech"] for row in state["radio"]], [
"Maintainer, Maintainer, this is Skills, ready, over",
"Maintainer, Maintainer, this is Skills, again, over",
"all stations, this is Maintainer, board, out",
"MAYDAY MAYDAY MAYDAY, this is Docs Docs Docs, disk full, over",
"PAN-PAN PAN-PAN PAN-PAN, all stations, this is Docs, slow, over",
"say-cure-ee-tay say-cure-ee-tay say-cure-ee-tay, all stations, this is Maintainer, rotate, over",
])
speech = self.httpd.hub.speech
self.assertEqual([row["voice"] for row in state["radio"]], [speech.voice_of(row["source"]) for row in state["radio"]])
self.assertTrue(all(row["voice"] in VOICES and row["voice"] != OPERATOR_VOICE for row in state["radio"]))
self.assertEqual(state["speech"], {
"tts": True, "stt": True, "tts_off": "", "stt_off": "", "voices": len(VOICES), "operator": OPERATOR_VOICE, "sample": "all stations, this is Operator, radio check, out",
"limit": phrasing.SPEECH_LIMIT, "rate": engines.STT_RATE, "seconds": engines.STT_SECONDS, "input": engines.INPUT_SECONDS, "gate": {"threshold": 50, "cpu": None, "open": False},
})
self.assertAlmostEqual(state["now"] - state["since"], view.RADIO_WINDOW)
self.assertEqual((state["night"], state["silence"]), ("day", None))
self.assertEqual(state["agent_order"], ["Skills session", "subagent general-purpose (default)", "Gatekeeper", "Maintainer", "Skills"])
radio = [(row["from"], row["to"], row["class"], row["text"]) for row in state["radio"]]
self.assertEqual(radio, [
("Skills", ["Maintainer"], "post", "ready"),
("Skills", ["Maintainer"], "post", "again"),
("Maintainer", [], "newsletter", "board"),
("Docs", [], "mayday", "MAYDAY disk full"),
("Docs", ["Skills"], "pan-pan", "PAN-PAN slow"),
("Maintainer", ["Skills", "Docs"], "security", "rotate"),
])
self.assertEqual([(row["office"], row["agent"], row["runtime"], row["kind"], row["dimension"], row["line"]) for row in state["claims"]], [
("chair", "Maintainer", "claude-code", "chair", "", ""),
("cluster/gate", "Gatekeeper", "codex", "cluster", "", ""),
("identity/oidc", "Skills", "claude", "line", "identity", "oidc"),
("work/hub", "Skills", "claude", "work", "", ""),
])
self.assertEqual([(row["to"], row["kind"], row["id"]) for row in state["grants"]], [("Skills", "gate", "q1")])
self.assertEqual([row["task"] for row in state["operator"]], ["operator/push"])
nodes = {node["id"]: node for node in state["graph"]["nodes"]}
moon = "subagent general-purpose (default) @ s1"
self.assertEqual(list(nodes), ["Operator", "s3", "name:Docs", "s2", "s1", moon])
self.assertEqual([nodes[key]["kind"] for key in nodes], ["operator", "chair", "session", "session", "session", "subagent"])
self.assertEqual([nodes[key]["label"] for key in nodes][:5], ["Operator", "Maintainer", "Docs", "Gatekeeper", "Skills"])
self.assertEqual((nodes[moon]["parent"], nodes[moon]["label"]), ("s1", "subagent general-purpose (default)"))
skills = [(task["task"], task["worker"], task["letters"]) for task in nodes["s1"]["tasks"]]
self.assertEqual(skills, [("operator/push", False, "A"), ("work/hub", True, "R"), ("work/sub", False, "A")])
self.assertEqual([(task["task"], task["letters"]) for task in nodes["Operator"]["tasks"]], [("operator/push", "R")])
self.assertEqual([task["task"] for task in nodes[moon]["tasks"]], ["work/sub"])
self.assertEqual([claim["office"] for claim in nodes["s1"]["claims"]], ["identity/oidc", "work/hub"])
self.assertEqual([claim["office"] for claim in nodes["s3"]["claims"]], ["chair"])
self.assertEqual((state["people"]["s1"]["now"], state["radio"][0]["source"], state["grants"][0]["target"]), ("Skills", "s1", "s1"))
edges = {(edge["source"], edge["target"], edge["class"]): edge["count"] for edge in state["graph"]["edges"]}
self.assertEqual(edges, {
("name:Docs", "*", "mayday"): 1,
("name:Docs", "s1", "pan-pan"): 1,
("s3", "*", "newsletter"): 1,
("s3", "name:Docs", "security"): 1,
("s3", "s1", "grant"): 1,
("s3", "s1", "security"): 1,
("s1", "s3", "post"): 2,
})
def test_state_needs_the_host(self):
for host in ("evil.example", f"evil.example:{self.port}", "127.0.0.1:1"):
with self.subTest(host=host):
self.assertEqual(self.call("GET", "/api/state", None, {"Host": host})[0], 403)
status, headers, _ = self.get("/api/state")
self.assertEqual(status, 200)
self.assertEqual(headers["content-security-policy"], exchange.PLAIN_CSP)
self.assertEqual(self.call("POST", "/api/state", b"", self.guard(self.host))[0], 404)
if __name__ == "__main__":
unittest.main()