feat(orchestrator): radio set with CPU-gated speech, noise burst, modes and log (requirement 004)

The hub gates uncached /api/tts renders on the latest W4 host CPU sample (503 busy or unknown, cached lines always served, signed speech.threshold 30 to 90 in steps of 10, speech.gate in /api/state). The page plays a WebAudio squelch-tail burst when no speech plays, offers Auto, Quiet and Silence per browser, and always sounds the MAYDAY, PAN-PAN and SECURITE procedure word. The radio panel becomes a minimalist VHF faceplate with display line, mode buttons, knobs, PTT send and the internet station; the settings dialog loses its radio section. The log gets Sent, Received and All tabs with class, sender, recipient and agent chips plus text search. Decisions 3 and 10 of 004 now state that the procedure word still sounds in Silence.

Security: MEDUSA-MEX-SCAN-1167 at orchestrator/kvb_orchestrator/hub.py:126 accepted as a false positive after the round 5 skeptic review and the operator pick of 2026-11-13 (regex hit on rce inside RESOURCES; CpuGate reads host CPU samples, no model).

Break risk 6 % is above the 5 % bar; committed and merged on the operator pick of 2026-11-13 for this bundle.

🎯 Fix: 92 %
💥 Break: 6 %
💸 Cost: 100 %
⏱️ Time: 100 %
🛡️ Security: 100 %
🏆 Score: 86
🚦 Gate: ⛔ break 6 % > 5

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Kevin Veen-BirkenbachandClaude Opus 5.5 committed 2026-11-13 10:48:13 +00:00
1 parent 69693ac2bc
commit acf39255fc
37 files changed
+2480 -356

No files matched your search

+283
View File
@@ -0,0 +1,283 @@
from __future__ import annotations
import dataclasses
import json
import os
import tempfile
import time
import unittest
from pathlib import Path
from unittest import mock
from hub_case import HubCase
from hub_engines import OPERATOR_VOICE, VOICES, log_rows, write_engines
from hub_support import STREAMS, key
from kvb_orchestrator import engines, errors, phrasing, settings, speechgate
LINE = "all stations, this is Docs, disk at ninety percent, out"
VOICE = "en_US-test-high:2"
WORDS = {
"mayday": "MAYDAY MAYDAY MAYDAY",
"pan-pan": "PAN-PAN PAN-PAN PAN-PAN",
"security": "say-cure-ee-tay say-cure-ee-tay say-cure-ee-tay",
}
SCRATCH = tempfile.TemporaryDirectory()
def scratch() -> Path:
return Path(tempfile.mkdtemp(dir=SCRATCH.name))
def gate_over(rows: list[dict], threshold: int, now: float) -> speechgate.CpuGate:
path = scratch() / "samples.jsonl"
path.write_text("".join(json.dumps(row) + "\n" for row in rows), encoding="utf-8")
return speechgate.CpuGate(samples=path, threshold=lambda: threshold, clock=lambda: now)
class TestLatestCpu(unittest.TestCase):
def test_the_newest_fresh_sample_counts_and_an_old_or_empty_one_does_not(self):
now = 1_800_000_000.0
cases = (
([{"t": now - 60, "cpu": 90.0}, {"t": now - 5, "cpu": 12.5}], 12.5),
([{"t": now - 120, "cpu": 33.0}], 33.0),
([{"t": now - 120.5, "cpu": 33.0}], None),
([{"t": now - 30, "cpu": 40.0}, {"t": now - 10, "cpu": None}], None),
([{"t": now - 30, "cpu": 40.0}, {"t": now - 10}], None),
([{"t": now - 10, "cpu": True}], None),
([{"t": now - 10, "cpu": "40"}], None),
([{"t": now - 10, "cpu": 140.0}], None),
([{"t": now + 600, "cpu": 10.0}], None),
([{"t": now - 20, "cpu": 70.0}, {"cpu": 1.0}], 70.0),
([], None),
)
for rows, expected in cases:
with self.subTest(rows=rows):
self.assertEqual(gate_over(rows, 50, now).state()["cpu"], expected)
def test_a_broken_last_line_is_skipped_and_only_the_tail_is_read(self):
now = 1_800_000_000.0
folder = scratch()
path = folder / "samples.jsonl"
old = "".join(json.dumps({"t": now - 86400 + index, "cpu": 99.0, "pad": "x" * 200}) + "\n" for index in range(2000))
path.write_text(old + json.dumps({"t": now - 3, "cpu": 21.0}) + "\n{broken\n", encoding="utf-8")
self.assertGreater(path.stat().st_size, speechgate.TAIL)
self.assertEqual(speechgate.latest_cpu(path, now), 21.0)
self.assertEqual(len(speechgate.tail_lines(path, speechgate.TAIL)), len(path.read_bytes()[-speechgate.TAIL:].splitlines()) - 1)
link = folder / "link.jsonl"
os.symlink(path, link)
self.assertEqual((speechgate.latest_cpu(link, now), speechgate.latest_cpu(folder / "missing.jsonl", now)), (None, None))
class TestCpuGate(unittest.TestCase):
def test_an_uncached_line_waits_at_or_above_the_threshold_and_without_a_fresh_sample(self):
now = 1_800_000_000.0
for cpu, threshold, reason in ((50.0, 50, "busy"), (91.0, 90, "busy"), (49.9, 50, None), (29.0, 30, None), (None, 50, "unknown")):
with self.subTest(cpu=cpu, threshold=threshold):
gate = gate_over([{"t": now - 1, "cpu": cpu}], threshold, now)
self.assertEqual(gate.state(), {"threshold": threshold, "cpu": cpu, "open": reason is None})
if reason is None:
self.assertIsNone(gate.admit(LINE))
continue
with self.assertRaises(errors.Held) as held:
gate.admit(LINE)
self.assertEqual(held.exception.reason, reason)
stale = gate_over([{"t": now - 121, "cpu": 5.0}], 50, now)
with self.assertRaises(errors.Held) as held:
stale.admit(LINE)
self.assertEqual((held.exception.reason, stale.state()["open"]), ("unknown", False))
def test_a_procedure_word_line_passes_under_load_and_without_a_sample(self):
now = 1_800_000_000.0
for rows in ([{"t": now - 1, "cpu": 99.0}], []):
gate = gate_over(rows, 50, now)
for line in WORDS.values():
with self.subTest(rows=rows, line=line):
self.assertIsNone(gate.admit(line))
with self.assertRaises(errors.Held):
gate.admit(f"{WORDS['mayday']}, this is Docs Docs Docs, over")
class TestProcedureWords(unittest.TestCase):
def test_alarm_rows_split_into_the_procedure_word_line_and_the_rest(self):
self.assertEqual({cls: phrasing.procedure(cls) for cls in WORDS}, WORDS)
self.assertEqual(phrasing.PROCEDURE_LINES, frozenset(WORDS.values()))
for cls in ("post", "call", "newsletter", "broadcast", "receipt"):
with self.subTest(cls=cls):
self.assertEqual(phrasing.procedure(cls), "")
word, rest = phrasing.phrase_parts(cls, "Docs", ["Skills"], "ready")
self.assertEqual((word, phrasing.phrase(cls, "Docs", ["Skills"], "ready")), ("", rest))
cases = (
("mayday", "MAYDAY disk full", "this is Docs Docs Docs, disk full, over"),
("pan-pan", "PAN-PAN slow", "all stations, this is Docs, slow, over"),
("security", "SECURITE rotate", "all stations, this is Docs, rotate, over"),
)
for cls, text, rest in cases:
with self.subTest(cls=cls):
self.assertEqual(phrasing.phrase_parts(cls, "Docs", [], text), (WORDS[cls], rest))
self.assertEqual(phrasing.phrase(cls, "Docs", [], text), f"{WORDS[cls]}, {rest}")
self.assertTrue(phrasing.SPOKEN_LINE.fullmatch(WORDS[cls]))
class TestThresholdSetting(unittest.TestCase):
def test_only_thirty_to_ninety_in_steps_of_ten_and_fifty_by_default(self):
self.assertEqual(settings.SETTINGS["speech"], {"threshold": 50})
for value in (30, 40, 50, 60, 70, 80, 90):
with self.subTest(value=value):
self.assertEqual(settings.speech_setting({"threshold": value}), {"threshold": value})
for value in (20, 25, 35, 95, 100, 0, 50.0, True, "50", None, [50]):
with self.subTest(value=value), self.assertRaises(errors.ToolError):
settings.speech_setting({"threshold": value})
for raw in ({}, {"threshold": 50, "on": True}, "50"):
with self.subTest(raw=raw), self.assertRaises(errors.ToolError):
settings.speech_setting(raw)
def test_settings_saved_before_the_radio_set_keep_every_hub_value(self):
legacy = {
**{key: value for key, value in settings.SETTINGS.items() if key != "speech"}, "latitude": 52.5, "streams": [{**STREAMS[0], "via": []}],
"sounds": {"mayday": {"on": True, "volume": 0.9}}, "squelch": 0.4, "speech": {"on": True, "classes": ["mayday"], "muted": ["s1"]},
}
with self.assertRaises(errors.ToolError):
settings.valid_settings(legacy)
folder = scratch()
(folder / "settings.json").write_text(json.dumps(legacy), encoding="utf-8")
loaded = settings.Settings(folder / "settings.json").get()
self.assertEqual((loaded["latitude"], loaded["streams"][0]["url"], loaded["speech"]), (52.5, STREAMS[0]["url"], {"threshold": 50}))
self.assertNotIn("sounds", loaded)
self.assertNotIn("squelch", loaded)
kept = {**legacy, "speech": {"on": False, "classes": ["mayday"], "muted": [], "threshold": 70}}
(folder / "settings.json").write_text(json.dumps(kept), encoding="utf-8")
self.assertEqual(settings.Settings(folder / "settings.json").get()["speech"], {"threshold": 70})
class TestHandedVoices(unittest.TestCase):
def test_procedure_lines_render_under_load_only_for_voices_the_hub_hands_out_and_outlive_the_trim(self):
base = scratch()
built = write_engines(base)
(built.voices / "many.onnx").write_bytes(b"onnx")
(built.voices / "many.onnx.json").write_text(json.dumps({"num_speakers": 904}), encoding="utf-8")
speech = engines.Speech(dataclasses.replace(built, operator_voice="many:0"), base / "tts")
now = 1_800_000_000.0
def ask(voice: str, line: str, cpu: float) -> int:
try:
speech.synthesize(json.dumps({"text": line, "voice": voice}).encode(), gate_over([{"t": now, "cpu": cpu}], 50, now).admit)
except errors.ToolError:
return 400
except errors.Held:
return 503
return 200
def renders() -> int:
return len(log_rows(built.scratch / "piper.jsonl"))
allowed = {speech.voice_of(key) for key in ("s1", "s2")} | {"many:0"}
strangers = [voice for voice in (f"many:{number}" for number in range(1, 251)) if voice not in allowed]
for _ in range(2):
self.assertEqual({ask(voice, WORDS["mayday"], 99.0) for voice in strangers}, {400})
self.assertEqual(sorted(ask(voice, WORDS["mayday"], 99.0) for voice in allowed), [200] * len(allowed))
self.assertEqual(renders(), len(allowed))
self.assertGreaterEqual(len(strangers), 247)
self.assertEqual(ask("many:0", LINE, 99.0), 503)
with mock.patch.object(engines, "TTS_KEEP", 1):
for number in range(3):
self.assertEqual(ask("many:0", f"{LINE} {number}", 10.0), 200)
kept = sorted(path.name.startswith(engines.WORD_CACHE) for path in (base / "tts").glob("*.wav"))
self.assertEqual(kept, [False] + [True] * len(allowed))
class TestSpeechGateHttp(HubCase):
def setUp(self):
super().setUp()
self.hand_out(VOICE)
def tts(self, text: str) -> tuple[int, dict, bytes]:
return self.post_json("/api/tts", {"text": text, "voice": VOICE}, self.guard(self.host))
def piper_calls(self) -> list[dict]:
return log_rows(self.engines.scratch / "piper.jsonl")
def test_an_uncached_line_answers_busy_or_unknown_and_piper_records_no_call(self):
for cpu, age, reason in ((50.0, 5, "busy"), (97.5, 0, "busy"), (None, 5, "unknown"), (10.0, 125, "unknown")):
with self.subTest(cpu=cpu, age=age):
self.host_cpu(cpu, age)
status, headers, body = self.tts(LINE)
self.assertEqual((status, headers["content-type"], json.loads(body)), (503, "application/json", {"reason": reason}))
(self.kept / "resources" / "samples.jsonl").unlink()
self.assertEqual(json.loads(self.tts(LINE)[2]), {"reason": "unknown"})
self.assertEqual(self.piper_calls(), [])
self.host_cpu(49.0, 5)
status, headers, _ = self.tts(LINE)
self.assertEqual((status, headers["content-type"]), (200, "audio/wav"))
self.assertEqual([row["text"] for row in self.piper_calls()], [f"{LINE}\n"])
def test_a_cached_line_answers_whatever_the_cpu(self):
self.host_cpu(12.0, 5)
first = self.tts(LINE)
self.assertEqual(first[0], 200)
for cpu, age in ((99.0, 5), (None, 5), (10.0, 900)):
with self.subTest(cpu=cpu, age=age):
self.host_cpu(cpu, age)
self.assertEqual(self.tts(LINE)[::2], (200, first[2]))
self.assertEqual(len(self.piper_calls()), 1)
self.assertEqual(self.tts(f"{LINE} again")[0], 503)
def test_a_procedure_word_line_renders_under_load_once_and_then_hits_the_cache(self):
self.host_cpu(99.0, 5)
for line in WORDS.values():
with self.subTest(line=line):
self.assertEqual(self.tts(line)[0], 200)
self.assertEqual(self.tts(line)[0], 200)
self.assertEqual([row["text"] for row in self.piper_calls()], [f"{line}\n" for line in WORDS.values()])
for voice, status in ((OPERATOR_VOICE, 200), (OPERATOR_VOICE, 200), *((voice, 400) for voice in VOICES if voice not in (VOICE, OPERATOR_VOICE))):
with self.subTest(voice=voice):
self.assertEqual(self.post_json("/api/tts", {"text": WORDS["mayday"], "voice": voice}, self.guard(self.host))[0], status)
self.assertEqual(len(self.piper_calls()), len(WORDS) + 1)
def test_the_state_carries_the_gate_and_the_rows_their_procedure_word(self):
self.write_council({"news.jsonl": self.jsonl([
{"ts": time.time() - 30, "from": "Docs", "to": [], "text": "MAYDAY disk full", "class": "mayday", "v": 2},
{"ts": time.time() - 20, "from": "Docs", "to": ["Skills"], "text": "ready", "class": "call", "v": 2},
])})
self.assertEqual(self.snapshot()["speech"]["gate"], {"threshold": 50, "cpu": None, "open": False})
self.host_cpu(42.0, 5)
self.assertEqual(self.snapshot()["speech"]["gate"], {"threshold": 50, "cpu": 42.0, "open": True})
self.host_cpu(50.0, 5)
state = self.snapshot()
self.assertEqual(state["speech"]["gate"], {"threshold": 50, "cpu": 50.0, "open": False})
rows = [(row["word"], row["rest"], row["speech"]) for row in state["radio"]]
self.assertEqual(rows, [
(WORDS["mayday"], "this is Docs Docs Docs, disk full, over", f"{WORDS['mayday']}, this is Docs Docs Docs, disk full, over"),
("", "Skills, Skills, this is Docs, ready, over", "Skills, Skills, this is Docs, ready, over"),
])
def test_the_threshold_changes_only_with_a_valid_passkey_signature(self):
good = self.guard(self.host)
current = self.snapshot()["settings"]
raised = {**current, "speech": {"threshold": 70}}
self.assertIsNone(json.loads(self.post_json("/api/settings/sign", current, good)[2])["payload"])
self.assertEqual(self.post_json("/api/settings", {**raised, "proof": None}, good)[:3:2], (400, b"not signed: no signature\n"))
signer = self.pin()
status, _, body = self.post_json("/api/settings/sign", raised, good)
self.assertEqual(status, 200, body)
request = json.loads(body)["payload"]
self.assertEqual(len(request["items"]), 1)
stranger = self.post_json("/api/settings", {**raised, "proof": key(-7, "stranger").proof(request, self.origin)}, good)
self.assertEqual(stranger[:3:2], (400, b"not signed: the signing key is not pinned\n"))
self.assertEqual(self.snapshot()["speech"]["gate"]["threshold"], 50)
lowered = {**current, "speech": {"threshold": 30}}
self.assertEqual(self.post_json("/api/settings", {**lowered, "proof": signer.proof(request, self.origin)}, good)[:3:2], (400, b"not signed: the signature does not list this item\n"))
status, _, body = self.post_json("/api/settings", {**raised, "proof": signer.proof(request, self.origin)}, good)
self.assertEqual((status, json.loads(body)["settings"]["speech"]), (200, {"threshold": 70}), body)
self.assertEqual(self.snapshot()["speech"]["gate"]["threshold"], 70)
self.assertEqual(settings.Settings(self.state / "settings.json").get()["speech"], {"threshold": 70})
for wrong in (35, 100, 20, "70", 70.0):
with self.subTest(wrong=wrong):
self.assertEqual(self.post_json("/api/settings/sign", {**current, "speech": {"threshold": wrong}}, good)[0], 400)
self.host_cpu(60.0, 5)
self.assertEqual(self.tts(LINE)[0], 200)
if __name__ == "__main__":
unittest.main()