From a388c6ef77c5d824c96b419e9b619cd6bb70f559 Mon Sep 17 00:00:00 2001 From: Kevin Veen-Birkenbach Date: Sun, 8 Nov 2026 13:37:02 +0000 Subject: [PATCH 1/7] fix(orchestrator): S1 fit, rename once, Deutschlandfunk e2e, squelch, tree cause MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Requirement 001 phase 6, S1: - Fit: Agents and Artifacts in a graph view fill the window from 861 px up (body.fit flex column); the e2e walk probes #agents/orbit at every width for a page no taller than the window. - Rename once: a session seen under two names by one source (two claims) flipped its name on every state build, so the Stream logged a rename each poll. Names.observe keeps only the newest sighting per session and source, and the timeline emits each (session, before, after) pair once. - Deutschlandfunk: root cause was the signed media-src, which never listed the redirect target f111.rndfnk.com that st01.sslstream.dlf.de answers with (fixed in ba97f7c). The e2e now replays that chain, a 302 from one https origin to a second, in Chromium and Firefox, with self-signed throwaway certificates the drivers accept. - Squelch: a settings slider 0..1 scales every tone; at 0 no beep plays, music on or off (Voice.beep skips a silent tone). Stored settings without the key load with 1.0. - Tree: the missing tree file error names `pkgmgr branch tree` and the release and install step that makes the timer write it. Evidence: make test 655 OK, ruff and markdownlint clean (/tmp/s1-make-test-1.log); e2e 17 OK, none skipped (/tmp/s1-e2e-3.log); MEDUSA 14 files, 0 findings. 🎯 Fix: 94 % 💥 Break: 4 % 💸 Cost: 100 % ⏱️ Time: – 🛡️ Security: 100 % 🏆 Score: 90 🚦 Gate: ✅ 90/5, cost and time <= 100, security 100 % Co-Authored-By: Claude Opus 5.5 --- docs/requirements/001-agent-orchestrator.md | 10 ++-- orchestrator/kvb_orchestrator/names.py | 20 ++++++- orchestrator/kvb_orchestrator/settings.py | 2 + orchestrator/kvb_orchestrator/tree.py | 5 +- orchestrator/templates/index.html.j2 | 8 +++ orchestrator/templates/page-alerts.js | 2 +- orchestrator/templates/page-screens.js | 1 + orchestrator/templates/page-settings.js | 4 +- orchestrator/templates/voice.js | 12 ++-- tests/e2e/bidi.mjs | 2 +- tests/e2e/cdp.mjs | 3 +- tests/e2e/test_orchestrator_e2e.py | 62 ++++++++++++++++++--- tests/test_hub_names.py | 31 +++++++++++ tests/test_hub_tree.py | 4 +- tests/test_hub_voice.py | 8 ++- 15 files changed, 148 insertions(+), 26 deletions(-) create mode 100644 tests/test_hub_names.py diff --git a/docs/requirements/001-agent-orchestrator.md b/docs/requirements/001-agent-orchestrator.md index cbbd626..cd525db 100644 --- a/docs/requirements/001-agent-orchestrator.md +++ b/docs/requirements/001-agent-orchestrator.md @@ -581,16 +581,16 @@ flowchart TD ### Phase 6: fixes (S1) -- [ ] `#agents/orbit` at 1920, 1366 and 390 px has +- [x] `#agents/orbit` at 1920, 1366 and 390 px has `document.documentElement.scrollHeight <= innerHeight` (e2e probe). -- [ ] Two state builds with the same claims add no second rename event to +- [x] Two state builds with the same claims add no second rename event to the Stream (unit test on the timeline). -- [ ] The Deutschlandfunk AAC stream plays in Chromium and Firefox through +- [x] The Deutschlandfunk AAC stream plays in Chromium and Firefox through the radio (e2e with a recorded fixture of its redirect chain) and the root cause is named in the commit message. -- [ ] With squelch at 0 no beep plays, music on or off (unit test on the +- [x] With squelch at 0 no beep plays, music on or off (unit test on the audio scheduler). -- [ ] Without a tree file the Tree names the missing `pkgmgr branch tree` +- [x] Without a tree file the Tree names the missing `pkgmgr branch tree` and the release step. ### Phase 6: popups and search (S2) diff --git a/orchestrator/kvb_orchestrator/names.py b/orchestrator/kvb_orchestrator/names.py index a2bf2a1..04531ba 100644 --- a/orchestrator/kvb_orchestrator/names.py +++ b/orchestrator/kvb_orchestrator/names.py @@ -65,9 +65,14 @@ class Directory: def renames(self, begin: float, end: float) -> list[dict]: found = [] + shown = set() for session, own in self.by_session.items(): for before, after in itertools.pairwise(own): - if before["name"] != after["name"] and begin <= after["first_seen"] <= end: + pair = (session, before["name"], after["name"]) + if before["name"] == after["name"] or pair in shown: + continue + shown.add(pair) + if begin <= after["first_seen"] <= end: found.append(event({ "id": f"rename:{session}:{after['first_seen']}", "ts": after["first_seen"], "kind": "rename", "agent": after["name"], "now": self.now(session), "session": session, "title": f"{before['name']} heißt jetzt {after['name']}", @@ -89,9 +94,20 @@ class Names: self.observed: dict[str, str] = observed if isinstance(observed, dict) else {} def observe(self, sightings: list[tuple[str, str, float | None, str]], now: float) -> None: + """Args: + sightings: (session, name, seen, source); of several sightings of + one session from one source only the newest counts, so two + claims under different names cannot flip the name back and + forth on every state build. + """ + newest: dict[tuple[str, str], tuple[str, str, float | None, str]] = {} + for sighting in sightings: + key = (sighting[0], sighting[3]) + if key not in newest or (sighting[2] or -math.inf) >= (newest[key][2] or -math.inf): + newest[key] = sighting with self.lock: changed = False - for session, name, seen, source in sightings: + for session, name, seen, source in newest.values(): key = f"{session}\x00{source}" if not session or not name or self.observed.get(key) == name: continue diff --git a/orchestrator/kvb_orchestrator/settings.py b/orchestrator/kvb_orchestrator/settings.py index 4c180c9..0316225 100644 --- a/orchestrator/kvb_orchestrator/settings.py +++ b/orchestrator/kvb_orchestrator/settings.py @@ -36,6 +36,7 @@ SETTINGS = { "direct": {"on": True, "volume": 0.5}, "radio": {"on": False, "volume": 0.25}, }, + "squelch": 1.0, "notify": True, "streams": [], "speech": {"on": False, "classes": ["mayday", "pan-pan", "security"], "muted": []}, @@ -195,6 +196,7 @@ def valid_settings(raw: object) -> dict: "colors": {key: color(colors[key], f"colors.{key}") for key in SETTINGS["colors"]}, "music": {"on": flag(music["on"], "music.on"), "volume": number_in(music["volume"], "music.volume", 0.0, 1.0)}, "sounds": {kind_name: tone_setting(sounds[kind_name], kind_name) for kind_name in TONES}, + "squelch": number_in(data["squelch"], "squelch", 0.0, 1.0), "notify": flag(data["notify"], "notify"), "streams": [stream_entry(entry, index) for index, entry in enumerate(data["streams"])], "speech": speech_setting(data["speech"]), diff --git a/orchestrator/kvb_orchestrator/tree.py b/orchestrator/kvb_orchestrator/tree.py index 628d205..a5c2d5d 100644 --- a/orchestrator/kvb_orchestrator/tree.py +++ b/orchestrator/kvb_orchestrator/tree.py @@ -191,7 +191,10 @@ class Tree: try: info = self.file.stat() except OSError as error: - return {"repos": [], "scanned": None, "error": f"no pkgmgr tree file at {self.file}: {error.strerror}"} + return {"repos": [], "scanned": None, "error": ( + f"no pkgmgr tree file at {self.file}: {error.strerror}. The tree timer runs `pkgmgr branch tree`, which the installed pkgmgr " + "lacks until a release ships it: release pkgmgr and install it, then the timer writes the file within a minute." + )} stamp = (info.st_mtime_ns, info.st_size) if self.cached is None or stamp != self.stamp: self.cached, self.stamp = read_tree(self.file), stamp diff --git a/orchestrator/templates/index.html.j2 b/orchestrator/templates/index.html.j2 index bcc7b12..91f65a7 100644 --- a/orchestrator/templates/index.html.j2 +++ b/orchestrator/templates/index.html.j2 @@ -209,6 +209,14 @@ table.diff tr.more td { padding: 8px 16px; color: var(--muted); font-style: ital .graph-body { display: grid; grid-template-columns: minmax(0, 1fr) 300px; gap: 14px; align-items: start; } .stage-card { padding: 8px; } .stage svg { display: block; width: 100%; height: auto; max-height: calc(100vh - var(--head) - 120px); } +@media (min-width: 861px) { + body.fit { display: flex; flex-direction: column; height: 100vh; } + body.fit .shell, body.fit main, body.fit .graph, body.fit .stage-card, body.fit .stage { display: flex; flex: 1; flex-direction: column; min-height: 0; } + body.fit main { padding-bottom: var(--sp-5); } + body.fit .graph-body { flex: 1; align-items: stretch; min-height: 0; } + body.fit .stage svg, body.fit .stage canvas.space, body.fit .graph3d { flex: 1; height: auto; min-height: 0; max-height: none; } + body.fit .panel { position: static; max-height: none; min-height: 0; overflow: auto; } +} .legend { display: flex; flex-wrap: wrap; gap: 6px 16px; padding: 6px 10px 4px; color: var(--muted); font-size: var(--fs-sm); } .legend span { display: inline-flex; align-items: center; gap: 6px; } .swatch { display: inline-block; width: 18px; height: 4px; border-radius: 2px; background: var(--c); } diff --git a/orchestrator/templates/page-alerts.js b/orchestrator/templates/page-alerts.js index 4d37aab..25fc6a3 100644 --- a/orchestrator/templates/page-alerts.js +++ b/orchestrator/templates/page-alerts.js @@ -47,7 +47,7 @@ const newRadio = state.radio.filter((row) => !known.radio.has(`${row.ts}|${row.from}|${row.text.slice(0, 40)}`)); const direct = newRadio.filter((row) => row.to.includes(HUMAN)); const present = {mayday: newAlarms.length > 0, review: fresh.some((item) => item.kind !== "operator"), direct: direct.length > 0, radio: newRadio.length > 0}; - const kind = SOUND_KINDS.map(([id]) => id).find((id) => present[id] && settings.sounds[id].on); + const kind = Voice.beep(present, settings, SOUND_KINDS.map(([id]) => id)); if (kind) { play(kind, loudness(kind)); } diff --git a/orchestrator/templates/page-screens.js b/orchestrator/templates/page-screens.js index 68ada43..7477fe7 100644 --- a/orchestrator/templates/page-screens.js +++ b/orchestrator/templates/page-screens.js @@ -70,6 +70,7 @@ const main = document.getElementById("main"); main.setAttribute("aria-labelledby", `tab-${ui.screen}`); main.replaceChildren(screenOf()); + document.body.classList.toggle("fit", ["agents", "artifacts"].includes(ui.screen) && !["tree", "hierarchy"].includes(ui.views[ui.screen])); drawn.screen = ui.screen; drawn.sig = sig; if (g3.host && !g3.host.isConnected) { diff --git a/orchestrator/templates/page-settings.js b/orchestrator/templates/page-settings.js index e4b8e12..f89a31a 100644 --- a/orchestrator/templates/page-settings.js +++ b/orchestrator/templates/page-settings.js @@ -111,6 +111,7 @@ const loudest = () => Math.max(...tones.map((tone) => Number(tone.level.value)), Number(volume.value)); return {id, on, level, row: h("div", {class: "sound-row"}, h("strong", {}, label), h("label", {class: "check"}, on, "an"), level, btn("Test", "btn small ghost", () => play(id, id === "mayday" ? loudest() : Number(level.value))))}; }); + const squelch = h("input", {type: "range", min: 0, max: 1, step: 0.05, value: settings.squelch, "aria-label": "Squelch"}); const notify = h("input", {type: "checkbox", checked: settings.notify}); const speechOn = h("input", {type: "checkbox", checked: settings.speech.on, disabled: !state.speech.tts}); const spoken = SPEECH_CLASSES.map(([id, label]) => ({id, label, box: h("input", {type: "checkbox", checked: id === "mayday" || settings.speech.classes.includes(id), disabled: id === "mayday", title: id === "mayday" ? "MAYDAY wird immer vorgelesen" : null})})); @@ -130,7 +131,7 @@ h("section", {}, h("h3", {}, "Musik"), h("p", {class: "muted"}, "Generative Ambient-Musik, offline erzeugt: ruhig bei leerer Inbox, etwas gespannter, wenn etwas wartet, leiser unter Meldungen."), h("div", {class: "grid"}, h("label", {class: "check"}, musicOn, "Musik an"), h("label", {}, "Gesamtlautstärke (Musik und Radio)", volume))), h("section", {}, h("h3", {}, "Töne und Benachrichtigungen"), h("p", {class: "muted"}, "MAYDAY und PAN-PAN sind immer am lautesten. Bei mehreren neuen Ereignissen spielt nur das dringendste."), - tones.map((tone) => tone.row), h("label", {class: "check"}, notify, "Desktop-Benachrichtigungen zeigen, wenn der Browser sie erlaubt")), + tones.map((tone) => tone.row), h("label", {}, "Squelch: scales every tone, 0 plays none", squelch), h("label", {class: "check"}, notify, "Desktop-Benachrichtigungen zeigen, wenn der Browser sie erlaubt")), h("section", {}, h("h3", {}, "Funk vorlesen"), h("p", {class: "muted"}, state.speech.tts ? "Neuer Funk wird in Seefunk-Sprechweise (SMCP) vorgelesen, eine Meldung nach der anderen, jede Station mit eigener Stimme; Musik und Radio werden solange leiser. Die Lautstärke folgt den Tönen oben, MAYDAY wird immer und am lautesten gesprochen." @@ -152,6 +153,7 @@ colors: Object.fromEntries(COLOR_FIELDS.map(([id]) => [id, colors[id].value])), music: {on: musicOn.checked, volume: Number(volume.value)}, sounds: Object.fromEntries(tones.map((tone) => [tone.id, {on: tone.on.checked, volume: Number(tone.level.value)}])), + squelch: Number(squelch.value), notify: notify.checked, streams: rows.map((entry) => entry.read()), speech: { diff --git a/orchestrator/templates/voice.js b/orchestrator/templates/voice.js index 18390ca..521678d 100644 --- a/orchestrator/templates/voice.js +++ b/orchestrator/templates/voice.js @@ -12,10 +12,12 @@ const Voice = (() => { } function loudness(tone, settings) { - if (tone !== "mayday") { - return settings.sounds[tone].volume; - } - return Math.max(...Object.values(settings.sounds).map((sound) => sound.volume), settings.music.volume); + const level = tone === "mayday" ? Math.max(...Object.values(settings.sounds).map((sound) => sound.volume), settings.music.volume) : settings.sounds[tone].volume; + return level * settings.squelch; + } + + function beep(present, settings, kinds) { + return kinds.find((kind) => present[kind] && settings.sounds[kind].on && loudness(kind, settings) > 0) || null; } function speakable(row, speech) { @@ -64,7 +66,7 @@ const Voice = (() => { return buffer; } - return {toneOf, loudness, speakable, enqueue, frames, wav}; + return {toneOf, loudness, beep, speakable, enqueue, frames, wav}; })(); if (typeof module === "object" && module.exports) { module.exports = Voice; diff --git a/tests/e2e/bidi.mjs b/tests/e2e/bidi.mjs index 7efc667..67036a7 100644 --- a/tests/e2e/bidi.mjs +++ b/tests/e2e/bidi.mjs @@ -66,7 +66,7 @@ function send(method, params) { const results = []; try { - await send("session.new", {capabilities: {}}); + await send("session.new", {capabilities: {alwaysMatch: {acceptInsecureCerts: true}}}); await send("session.subscribe", {events: ["log.entryAdded"]}); if (plan.init) { await send("script.addPreloadScript", {functionDeclaration: plan.init}); diff --git a/tests/e2e/cdp.mjs b/tests/e2e/cdp.mjs index 763961a..38a41f0 100644 --- a/tests/e2e/cdp.mjs +++ b/tests/e2e/cdp.mjs @@ -13,7 +13,8 @@ const plan = JSON.parse(readFileSync(planFile, "utf8")); const profile = mkdtempSync(join(tmpdir(), "cdp-")); // --no-sandbox: the agent sandbox already forbids the user namespaces Chromium's own sandbox needs. // --enable-unsafe-swiftshader: without a GPU, headless Chromium gives WebGL only through SwiftShader, which it no longer enables by itself. -const flags = ["--headless", "--no-sandbox", "--disable-gpu", "--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--use-fake-device-for-media-stream", "--use-fake-ui-for-media-stream", "--no-first-run", "--no-default-browser-check", "--hide-scrollbars", `--user-data-dir=${profile}`, "--remote-debugging-port=0", "about:blank"]; +// --ignore-certificate-errors: the https station fixtures use a throwaway self-signed certificate. +const flags = ["--headless", "--no-sandbox", "--disable-gpu", "--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--ignore-certificate-errors", "--use-fake-device-for-media-stream", "--use-fake-ui-for-media-stream", "--no-first-run", "--no-default-browser-check", "--hide-scrollbars", `--user-data-dir=${profile}`, "--remote-debugging-port=0", "about:blank"]; const browser = spawn(binary, flags, {stdio: ["ignore", "ignore", "pipe"]}); const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); const KEYS = {Enter: [13, "\r"], Tab: [9, ""]}; diff --git a/tests/e2e/test_orchestrator_e2e.py b/tests/e2e/test_orchestrator_e2e.py index e657595..c8f3d78 100644 --- a/tests/e2e/test_orchestrator_e2e.py +++ b/tests/e2e/test_orchestrator_e2e.py @@ -8,6 +8,7 @@ import json import math import os import shutil +import ssl import subprocess import sys import tempfile @@ -17,6 +18,7 @@ import unittest from collections.abc import Callable from pathlib import Path from unittest import mock +from urllib.parse import urlsplit HERE = Path(__file__).resolve().parent sys.path.insert(0, str(HERE.parent)) @@ -101,6 +103,7 @@ PROBE = """(async () => {@HELPERS@ flowEdges: all("#main svg.chart path.flow").map((path) => path.dataset.side), openWork: all("#main .open-work").length, wide: document.documentElement.scrollWidth > window.innerWidth + 1, + tall: document.documentElement.scrollHeight > window.innerHeight, }; })()""".replace("@HELPERS@", HELPERS) ORG_OPEN = """(async () => {@HELPERS@ @@ -351,6 +354,8 @@ ADD_STATION = """(async () => {@HELPERS@ return {toasts: all("#toasts .toast").map(text)}; })()""".replace("@HELPERS@", HELPERS) STATION_NAME = "E2E Ton mit einem sehr langen Sendernamen, der in keine Zeile passt" +DLF_PATH = "/dlf/01/high/aac/stream.aac?aggregator=web" +DLF_NODE = "/ard/dlf/01/aac/192/stream.aac?aggregator=web" RADIO_STATE = """(async () => {@HELPERS@@MEDIA@ await until(() => log().some((entry) => entry.play), 8000); return {log: log(), media: await advancing(), toasts: all("#toasts .toast").map(text)}; @@ -481,6 +486,12 @@ def tone(seconds: int, rate: int) -> bytes: class Station(http.server.BaseHTTPRequestHandler): def do_GET(self) -> None: + if self.server.moved: + self.send_response(302) + self.send_header("Location", self.server.moved) + self.send_header("Content-Length", "0") + self.end_headers() + return body = self.server.body self.send_response(200) self.send_header("Content-Type", "audio/wav") @@ -677,15 +688,41 @@ class TestOrchestratorE2E(HubCase): patch.start() self.addCleanup(patch.stop) - def station(self) -> str: + def station(self, tls: ssl.SSLContext | None = None, moved: str | None = None) -> str: + """Args: + tls: serves https with this context instead of plain http. + moved: answers every request with a 302 to this URL instead of + the tone. + """ httpd = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Station) - httpd.body = tone(30, 22050) + httpd.body, httpd.moved = tone(30, 22050), moved + if tls: + httpd.socket = tls.wrap_socket(httpd.socket, server_side=True) thread = threading.Thread(target=httpd.serve_forever, args=(0.05,), daemon=True) thread.start() self.addCleanup(httpd.server_close) self.addCleanup(thread.join, 10) self.addCleanup(httpd.shutdown) - return f"http://127.0.0.1:{httpd.server_address[1]}/tone.wav" + return f"{'https' if tls else 'http'}://127.0.0.1:{httpd.server_address[1]}{DLF_PATH if moved else '/tone.wav'}" + + def redirected(self) -> tuple[str, list[str]]: + """Returns: + A station that replays the recorded Deutschlandfunk chain, a 302 + from st01.sslstream.dlf.de to an f111.rndfnk.com node, as a 302 to + a second https origin, and that origin as its released via. + """ + folder = Path(tempfile.mkdtemp()) + self.addCleanup(shutil.rmtree, folder) + key, cert = folder / "key.pem", folder / "cert.pem" + subprocess.run([ + "openssl", "req", "-x509", "-newkey", "ec", "-pkeyopt", "ec_paramgen_curve:P-256", "-nodes", "-subj", "/CN=127.0.0.1", + "-addext", "subjectAltName=IP:127.0.0.1", "-days", "1", "-keyout", str(key), "-out", str(cert), + ], capture_output=True, timeout=60, check=True) + tls = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) + tls.load_cert_chain(cert, key) + node = urlsplit(self.station(tls)) + origin = f"https://{node.netloc}" + return self.station(tls, f"{origin}{DLF_NODE}"), [origin] def check_overlaps(self, browser: str, driver: str, binary: str) -> None: steps = [] @@ -706,20 +743,23 @@ class TestOrchestratorE2E(HubCase): self.assertIn("Verzeichnis (Glob)", rules["review"]["labels"]) self.assertEqual(settings, {"found": [], "outside": []}) - def check_radio(self, browser: str, driver: str, binary: str) -> dict: + def check_radio(self, browser: str, driver: str, binary: str, redirected: bool = False) -> dict: """Args: driver: cdp.mjs saves the station through the settings form and signs its new origin with a virtual passkey; bidi.mjs has no virtual authenticator, so the station is saved before the page loads. + redirected: plays the recorded Deutschlandfunk redirect chain, + saved before the page loads with its resolved via. """ - station = self.station() - signs = driver == "cdp.mjs" + station, via = self.redirected() if redirected else (self.station(), []) + browser = f"{browser}-dlf" if redirected else browser + signs = driver == "cdp.mjs" and not redirected if signs: first = {"width": 1366, "height": 768, "url": f"http://localhost:{self.port}/#stream", "wait": 900, "probe": ADD_STATION.replace("@STATION@", station).replace("@NAME@", STATION_NAME), "shot": None, "gesture": True} else: hub = self.httpd.hub - hub.settings.put({**hub.settings.get(), "streams": [{"name": STATION_NAME, "url": station, "from": "00:00", "to": "24:00", "days": list(range(7)), "on": True, "via": []}]}, hub.settings.get()) + hub.settings.put({**hub.settings.get(), "streams": [{"name": STATION_NAME, "url": station, "from": "00:00", "to": "24:00", "days": list(range(7)), "on": True, "via": via}]}, hub.settings.get()) first = {"width": 1366, "height": 768, "url": f"{self.base}#stream", "wait": 900, "probe": None, "shot": None} steps = [ first, @@ -761,6 +801,13 @@ class TestOrchestratorE2E(HubCase): def test_firefox_plays_a_saved_station(self): self.check_radio("firefox", "bidi.mjs", os.environ.get("FIREFOX", "firefox")) + def test_chromium_plays_deutschlandfunk_through_its_redirect(self): + self.check_radio("chromium", "cdp.mjs", os.environ.get("CHROMIUM", "chromium"), redirected=True) + + @unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox") + def test_firefox_plays_deutschlandfunk_through_its_redirect(self): + self.check_radio("firefox", "bidi.mjs", os.environ.get("FIREFOX", "firefox"), redirected=True) + def test_chromium_walks_every_screen_at_three_widths(self): steps = [{"width": width, "height": height, "url": f"{self.base}#{screen}", "wait": 900, "probe": PROBE, "shot": self.shot(f"{width}-{screen.replace('/', '-')}")} for width, height in WIDTHS for screen in SCREENS] steps += [{"width": 1366, "height": 768, "url": f"{self.base}#{old}", "wait": 600, "probe": PROBE, "shot": None} for old in ("graph", "graph/chord", "tree")] @@ -786,6 +833,7 @@ class TestOrchestratorE2E(HubCase): self.assertGreater(probe["icons"], 8) self.assertEqual(labelled(probe), {"unlabelled": [], "broken": []}) self.assertFalse(probe["wide"], "the page scrolls sideways") + self.assertEqual([probe["tall"] for probe in probes if probe["hash"] == "#agents/orbit"], [False] * len(WIDTHS)) by_hash = {probe["hash"]: probe for probe in probes} stream = by_hash["#stream"] self.assertEqual([probe["chips"] for probe in probes if probe["hash"] == "#stream"], [["Für dich", "Funk", "Arbeit", "Transkripte"]] * len(WIDTHS)) diff --git a/tests/test_hub_names.py b/tests/test_hub_names.py new file mode 100644 index 0000000..c3080f8 --- /dev/null +++ b/tests/test_hub_names.py @@ -0,0 +1,31 @@ +from __future__ import annotations + +import tempfile +import unittest +from pathlib import Path + +import hub_support # noqa: F401 +from kvb_orchestrator import names + + +class TestRenameOnce(unittest.TestCase): + def test_two_state_builds_with_the_same_claims_add_no_second_rename(self): + with tempfile.TemporaryDirectory() as folder: + book = names.Names(Path(folder) / "names.json") + claims = [("s1", "Stage", 100.0, "claim"), ("s1", "i18n 2.0", 200.0, "claim"), ("s2", "Main", 50.0, "claim")] + counts = [] + for build in (1000.0, 2000.0): + book.observe(claims, build) + counts.append(len(names.Directory(book.listed()).renames(0, 3000))) + self.assertEqual(counts, [0, 0]) + for build in (3000.0, 4000.0): + book.observe([*claims, ("s1", "Skills", 300.0, "title")], build) + self.assertEqual([row["title"] for row in names.Directory(book.listed()).renames(0, 5000)], ["i18n 2.0 heißt jetzt Skills"]) + + def test_a_name_pair_shows_once_per_session(self): + entries = [{"session": "s1", "name": name, "first_seen": ts, "source": "claim"} for name, ts in (("A", 1), ("B", 2), ("A", 3), ("B", 4))] + self.assertEqual([row["title"] for row in names.Directory(entries).renames(0, 10)], ["A heißt jetzt B", "B heißt jetzt A"]) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_hub_tree.py b/tests/test_hub_tree.py index e133830..3e2da7c 100644 --- a/tests/test_hub_tree.py +++ b/tests/test_hub_tree.py @@ -52,7 +52,9 @@ class TestHubTree(HubCase): status, _, body = self.get("/api/tree") self.assertEqual(status, 200, body) self.assertEqual((json.loads(body)["repos"], json.loads(body)["scanned"]), ([], None)) - self.assertIn("no pkgmgr tree file", json.loads(body)["error"]) + for words in ("no pkgmgr tree file", "`pkgmgr branch tree`", "release pkgmgr"): + with self.subTest(words=words): + self.assertIn(words, json.loads(body)["error"]) self.tree_file.write_text('{"repos": [{"path": "/x"}]}', encoding="utf-8") self.assertIn("unreadable", json.loads(self.get("/api/tree")[2])["error"]) diff --git a/tests/test_hub_voice.py b/tests/test_hub_voice.py index 292ecc2..ab7f172 100644 --- a/tests/test_hub_voice.py +++ b/tests/test_hub_voice.py @@ -38,6 +38,7 @@ console.log(JSON.stringify({ spoken: filters.map((filter) => rows.map((row) => V.speakable(row, filter))), queue: pending.map((item) => item.cls), loud: settings.map((one) => Object.fromEntries(["mayday", "review", "direct", "radio"].map((tone) => [tone, V.loudness(tone, one)]))), + beeps: settings.map((one) => V.beep({mayday: true, review: true, direct: true, radio: true}, one, ["mayday", "review", "direct", "radio"])), frames: [V.frames(1.5, 16000, 120), V.frames(130, 16000, 120), V.frames(0, 16000, 120)], wav: Buffer.from(V.wav(Float32Array.from([0, 0.5, -0.5, 1, -1, 2, -2]), 16000)).toString("base64"), })); @@ -52,6 +53,7 @@ class TestVoiceModule(unittest.TestCase): settings.SETTINGS, {**settings.SETTINGS, "music": {"on": True, "volume": 1.0}, "sounds": quiet}, {**settings.SETTINGS, "sounds": {**settings.SETTINGS["sounds"], "mayday": {"on": True, "volume": 0.0}, "radio": {"on": True, "volume": 0.8}}}, + *({**settings.SETTINGS, "squelch": 0.0, "music": {"on": music, "volume": 1.0}, "sounds": {name: {"on": True, "volume": 1.0} for name in settings.TONES}} for music in (True, False)), ] command = ["node", "-e", VOICE_PROBE, str(VOICE), json.dumps(cls.settings)] done = subprocess.run(command, capture_output=True, text=True, timeout=60, check=True) @@ -63,7 +65,11 @@ class TestVoiceModule(unittest.TestCase): for loud in self.data["loud"]: with self.subTest(loud=loud): self.assertEqual(loud["mayday"], max(loud.values())) - self.assertEqual([loud["mayday"] for loud in self.data["loud"]], [0.9, 1.0, 0.8]) + self.assertEqual([loud["mayday"] for loud in self.data["loud"]], [0.9, 1.0, 0.8, 0.0, 0.0]) + + def test_squelch_at_zero_plays_no_tone_with_music_on_or_off(self): + self.assertEqual(self.data["beeps"], ["mayday", None, "mayday", None, None]) + self.assertEqual([set(loud.values()) for loud in self.data["loud"][3:]], [{0.0}, {0.0}]) def test_the_radio_filter_picks_classes_and_stations(self): self.assertEqual(self.data["spoken"], [ From c0353735180625ffc6b4d284277040b64d06a7f8 Mon Sep 17 00:00:00 2001 From: Kevin Veen-Birkenbach Date: Sun, 8 Nov 2026 17:26:51 +0000 Subject: [PATCH 2/7] =?UTF-8?q?feat(orchestrator)!:=20S0=20English=20every?= =?UTF-8?q?where,=20S=C3=A9curit=C3=A9,=20NATO=20hashes,=20ICAO=20digits?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Requirement 001 phase 6, S0: - Speech: the security class shows as "Sécurité" and is spoken as in maritime radio, "say-cure-ee-tay" three times. A hex run of 7 or more characters with a letter and a digit (commit, session, message ids) is spelled in the NATO alphabet; every other digit is spoken on its own in ICAO pronunciation (42305: four two tree zero fife). The spelling runs inside clip() before the length cut, so a phrase still fits SPEECH_LIMIT; the displayed text keeps its digits and hashes. - English: every orchestrator label, tooltip, message, error, script output, document and test string is English (Regeln -> Firewall, Hierarchie -> Hierarchy, Steuerung -> Controls, Ausführen -> Run, ...); the page declares lang="en" and formats dates as en-GB. Task filter ids are English. German stays only in the skill trigger phrases that quote the operator, and as identifiers: the view keys (view=) and the leitstand id. - tests/test_english.py scans every tracked text file for umlauts and German words, with an allowlist of the quoted trigger phrases. BREAKING CHANGE: the Stream search tokens art: and seit: are now kind: and since:; an old art: or seit: token counts as a plain word. Evidence: make test 657 OK, ruff and markdownlint clean (/tmp/s0-make-test-1.log); e2e 17 OK, none skipped (/tmp/s0-e2e-1.log); MEDUSA 86 files, 24 findings on reworded strings accepted after an independent skeptic (21 path:line, 0 rejected, no behaviour change in signing, approving, rules, denying, offices, events), rescan 0 open. 🎯 Fix: 93 % 💥 Break: 4 % 💸 Cost: 100 % ⏱️ Time: – 🛡️ Security: 100 % 🏆 Score: 89 🚦 Gate: ✅ 90/5, cost and time <= 100, security 100 % Co-Authored-By: Claude Opus 5.5 --- README.md | 12 +- docs/requirements/001-agent-orchestrator.md | 75 +++--- orchestrator/client/signing.py | 12 +- orchestrator/kvb_orchestrator/approving.py | 22 +- orchestrator/kvb_orchestrator/cleanup.py | 4 +- orchestrator/kvb_orchestrator/crons.py | 4 +- orchestrator/kvb_orchestrator/denying.py | 24 +- orchestrator/kvb_orchestrator/events.py | 34 +-- orchestrator/kvb_orchestrator/jobs.py | 6 +- orchestrator/kvb_orchestrator/language.py | 14 +- orchestrator/kvb_orchestrator/names.py | 4 +- orchestrator/kvb_orchestrator/offices.py | 4 +- orchestrator/kvb_orchestrator/phrasing.py | 26 +- orchestrator/kvb_orchestrator/requesting.py | 6 +- orchestrator/kvb_orchestrator/rules.py | 2 +- orchestrator/kvb_orchestrator/tasking.py | 2 +- orchestrator/kvb_orchestrator/timeline.py | 2 +- orchestrator/kvb_orchestrator/tree.py | 12 +- orchestrator/templates/index.html.j2 | 8 +- orchestrator/templates/nav.js | 6 +- orchestrator/templates/page-agent-order.js | 18 +- orchestrator/templates/page-agent.js | 40 ++-- orchestrator/templates/page-alerts.js | 10 +- orchestrator/templates/page-artifacts.js | 54 ++--- orchestrator/templates/page-board.js | 22 +- orchestrator/templates/page-cleanup.js | 24 +- orchestrator/templates/page-composer.js | 64 ++--- orchestrator/templates/page-console.js | 14 +- orchestrator/templates/page-constants.js | 44 ++-- orchestrator/templates/page-deny.js | 30 +-- orchestrator/templates/page-dom.js | 20 +- orchestrator/templates/page-filters.js | 14 +- orchestrator/templates/page-flow.js | 20 +- orchestrator/templates/page-graph-charts.js | 28 +-- orchestrator/templates/page-graph-layout.js | 4 +- orchestrator/templates/page-graph3d.js | 26 +- orchestrator/templates/page-hierarchy.js | 32 +-- orchestrator/templates/page-inbox.js | 72 +++--- orchestrator/templates/page-keyboard.js | 4 +- orchestrator/templates/page-music.js | 2 +- orchestrator/templates/page-offices.js | 36 +-- orchestrator/templates/page-palette.js | 44 ++-- orchestrator/templates/page-passkey.js | 24 +- orchestrator/templates/page-radio.js | 32 +-- orchestrator/templates/page-radioview.js | 38 +-- orchestrator/templates/page-review.js | 16 +- orchestrator/templates/page-rule-request.js | 12 +- orchestrator/templates/page-rules.js | 44 ++-- orchestrator/templates/page-screens.js | 4 +- orchestrator/templates/page-settings.js | 80 +++---- orchestrator/templates/page-sky.js | 26 +- orchestrator/templates/page-spawn.js | 8 +- orchestrator/templates/page-speech.js | 16 +- orchestrator/templates/page-stream.js | 38 +-- orchestrator/templates/page-tasks-prio.js | 54 ++--- orchestrator/templates/page-tasks.js | 58 ++--- orchestrator/templates/page-time.js | 26 +- orchestrator/templates/page-tree.js | 66 +++--- scripts/orchestrator.sh | 6 +- skills/kvb-check-legal/SKILL.md | 4 +- skills/kvb-org-organize/succession.md | 2 +- tests/e2e/test_orchestrator_e2e.py | 248 ++++++++++---------- tests/hub_support.py | 6 +- tests/test_coach.py | 20 +- tests/test_english.py | 64 +++++ tests/test_hub_ambience.py | 2 +- tests/test_hub_approval.py | 4 +- tests/test_hub_board.py | 10 +- tests/test_hub_cleanup.py | 14 +- tests/test_hub_composer.py | 34 +-- tests/test_hub_console.py | 2 +- tests/test_hub_deny.py | 10 +- tests/test_hub_graph.py | 2 +- tests/test_hub_inbox.py | 8 +- tests/test_hub_names.py | 4 +- tests/test_hub_nav.py | 6 +- tests/test_hub_radio_trouble.py | 4 +- tests/test_hub_redirects.py | 8 +- tests/test_hub_rule_requests.py | 2 +- tests/test_hub_settings.py | 14 +- tests/test_hub_space.py | 2 +- tests/test_hub_speech.py | 14 +- tests/test_hub_state.py | 2 +- tests/test_hub_stream.py | 4 +- tests/test_hub_surface.py | 14 +- tests/test_hub_tasks.py | 4 +- 86 files changed, 1027 insertions(+), 930 deletions(-) create mode 100644 tests/test_english.py diff --git a/README.md b/README.md index 4a58106..386fa32 100644 --- a/README.md +++ b/README.md @@ -405,17 +405,17 @@ Both commands also patch the target's `.claude/settings.local.json` — the mach The global install also runs the Agent Orchestrator, a local review page in which the operator approves or rejects the agents' staged commits (the `kvb-git-diff` skill): it copies `orchestrator/` to `~/.local/share/kvb-orchestrator`, starts it there with `docker compose up -d --build` (restart `unless-stopped`, bound to `127.0.0.1` only, state in `~/.local/state/kvb-orchestrator`) and registers its MCP server for Claude Code at user scope. Its port is `KVB_ORCHESTRATOR_PORT` in `orchestrator/.env`; the hub page is `http://localhost:/`, the MCP endpoint `/mcp`. Without docker the hub is skipped and the commit skills ask in chat. The hub reads new radio traffic aloud in maritime phraseology and takes push-to-talk input; its image builds both engines from pinned, sha256-verified sources and runs each as a separate process: Piper (`piper-tts`, GPL-3.0-or-later) with the `en_US-libritts-high` voice (904 speakers, trained on LibriTTS, CC BY 4.0, from `rhasspy/piper-voices`) and whisper.cpp (MIT) with the multilingual `ggml-base-q8_0` model (OpenAI Whisper weights, MIT, 82 MB). The operator's own voice is `KVB_ORCHESTRATOR_OPERATOR_VOICE` in `orchestrator/.env`. Its Tree reads only the file `pkgmgr branch tree` writes: the install clones `PKGMGR_REPO` (default the GitHub repository, never the sandbox-writable local checkout), builds the newest `v*` tag a fully trusted GPG key signed into `~/.local/share/kvb-orchestrator/pkgmgr`, and enables the `kvb-orchestrator-tree.timer` user timer, which writes `~/.local/state/pkgmgr/tree/branch-tree.json` a minute after its previous run while the hub page polls, on at most half a core; the hub mounts that directory read-only and starts no git. A signed tag without `branch tree` leaves the timer off. -Stream → Radio (`#stream/radio`) is the hub's radio interface. Its station list shows one line per station, the full name in the tooltip, with its state and a play or stop button; when the browser blocks autoplay, the stream fails or the CSP refuses its origin, the row and a toast say so, and one click starts the station. New stations play daily around the clock. While the hub reads a message aloud, the speaking agent pulses there and in the Orbit and Chord views, under the caption " spricht" with the message's first line; under `prefers-reduced-motion` the ring stays still. The composer sends on all seven channels: post and call to one agent, newsletter, broadcast, pan-pan, security and mayday to all. "Aufnehmen" records with MediaRecorder; the hub transcribes the recording with whisper.cpp off the request thread (at most 120 s of audio, a 120 s timeout, four at a time), keeps it for replay in `~/.local/state/kvb-orchestrator/voice` (the newest 50) and puts the transcript into the field to edit; the message goes out as text, with the recording's host path and sha256 only when "Aufnahme anhängen" is ticked. The hub transcribes at most six recordings a minute and 600 s of audio an hour. Every operator message is passkey-signed, and the hub verifies the signature against the pinned keys, each once, before it relays; `operator_message(id, text, to)` answers `match` only for the signed text and recipient; for a denial the signature covers the recipient the inbox resolved at signing, and the answer's text is only the signed reason, never the agent's own words the radio row quotes. "Mayday aufheben", Abend, Sonnenuntergang, Sonnenaufgang and a settings save that adds a stream URL take the passkey the same way. +Stream → Radio (`#stream/radio`) is the hub's radio interface. Its station list shows one line per station, the full name in the tooltip, with its state and a play or stop button; when the browser blocks autoplay, the stream fails or the CSP refuses its origin, the row and a toast say so, and one click starts the station. New stations play daily around the clock. While the hub reads a message aloud, the speaking agent pulses there and in the Orbit and Chord views, under the caption " speaking" with the message's first line; under `prefers-reduced-motion` the ring stays still. The composer sends on all seven channels: post and call to one agent, newsletter, broadcast, pan-pan, security and mayday to all. "Record" records with MediaRecorder; the hub transcribes the recording with whisper.cpp off the request thread (at most 120 s of audio, a 120 s timeout, four at a time), keeps it for replay in `~/.local/state/kvb-orchestrator/voice` (the newest 50) and puts the transcript into the field to edit; the message goes out as text, with the recording's host path and sha256 only when "Attach recording" is ticked. The hub transcribes at most six recordings a minute and 600 s of audio an hour. Every operator message is passkey-signed, and the hub verifies the signature against the pinned keys, each once, before it relays; `operator_message(id, text, to)` answers `match` only for the signed text and recipient; for a denial the signature covers the recipient the inbox resolved at signing, and the answer's text is only the signed reason, never the agent's own words the radio row quotes. "Cancel mayday", Evening, Sunset, Sunrise and a settings save that adds a stream URL take the passkey the same way. -The hub page loads nothing from the network: its icons come from Bootstrap Icons 1.13.1 (`orchestrator/vendor/bootstrap-icons`, MIT), inlined per page as the symbols it uses, and its 3D views from `3d-force-graph` 1.80.1 and `three` 0.186.1 (`orchestrator/vendor`, MIT, served by the hub under `/vendor/`). In the Artifacts Tree, "Löschen" on a `merged-clean` branch without skip reason, or "Alle gemergten löschen", shows the dry-run lines and asks for the passkey signature; the hub then writes a job (repository, branch, worktree and tip per item, no command) into `~/.local/state/kvb-orchestrator/cleanup/jobs`. The `kvb-orchestrator-cleanup.path` user unit runs `client/cleanup.py` on the host, which verifies the signature against the pinned keys, runs `pkgmgr branch cleanup --json --local --branch ` as a dry run in the repository, then `--apply` only when that plan names exactly the signed branch as `merged-clean` at the signed tip and worktree, refuses everything else unchanged, writes each result to `cleanup/results` and rewrites the tree file. The buttons stay disabled while the tree file says `delete_ready: false`. +The hub page loads nothing from the network: its icons come from Bootstrap Icons 1.13.1 (`orchestrator/vendor/bootstrap-icons`, MIT), inlined per page as the symbols it uses, and its 3D views from `3d-force-graph` 1.80.1 and `three` 0.186.1 (`orchestrator/vendor`, MIT, served by the hub under `/vendor/`). In the Artifacts Tree, "Delete" on a `merged-clean` branch without skip reason, or "Delete all merged", shows the dry-run lines and asks for the passkey signature; the hub then writes a job (repository, branch, worktree and tip per item, no command) into `~/.local/state/kvb-orchestrator/cleanup/jobs`. The `kvb-orchestrator-cleanup.path` user unit runs `client/cleanup.py` on the host, which verifies the signature against the pinned keys, runs `pkgmgr branch cleanup --json --local --branch ` as a dry run in the repository, then `--apply` only when that plan names exactly the signed branch as `merged-clean` at the signed tip and worktree, refuses everything else unchanged, writes each result to `cleanup/results` and rewrites the tree file. The buttons stay disabled while the tree file says `delete_ready: false`. -The Agents view "Hierarchie" draws the council's formal offices as a collapsible org chart: Operator, chair, dimensions with their line representatives, organisers (`cluster/`) and presidents (`work/`); the chair in every graph is the holder of the `chair` office, not a fixed name. Appointing, handing over or recalling an office there asks for the passkey signature; the hub writes a job (office, signed holder, successor session, work; no command) into `~/.local/state/kvb-orchestrator/offices/jobs`, and the `kvb-orchestrator-offices.path` user unit runs `client/offices.py` on the host, which verifies the signature, refuses a council directory others can write, a link on the path or a holder that changed since the signature. For a takeover or recall it moves the office aside and removes it only while the claim there still names the signed holder; an appoint or takeover then runs a plain `council.py claim ` for the successor by argv. council.py itself has no flag that overrides a live holder. The same view holds the operator's agent order as a drag list with up and down buttons: `rasci.py agents order` stores it in `agent-order.json` beside the register, where it breaks ties of equal task priority and orders the chair's grants without touching any task's `--prio` pin. +The Agents view "Hierarchy" draws the council's formal offices as a collapsible org chart: Operator, chair, dimensions with their line representatives, organisers (`cluster/`) and presidents (`work/`); the chair in every graph is the holder of the `chair` office, not a fixed name. Appointing, handing over or recalling an office there asks for the passkey signature; the hub writes a job (office, signed holder, successor session, work; no command) into `~/.local/state/kvb-orchestrator/offices/jobs`, and the `kvb-orchestrator-offices.path` user unit runs `client/offices.py` on the host, which verifies the signature, refuses a council directory others can write, a link on the path or a holder that changed since the signature. For a takeover or recall it moves the office aside and removes it only while the claim there still names the signed holder; an appoint or takeover then runs a plain `council.py claim ` for the successor by argv. council.py itself has no flag that overrides a live holder. The same view holds the operator's agent order as a drag list with up and down buttons: `rasci.py agents order` stores it in `agent-order.json` beside the register, where it breaks ties of equal task priority and orders the chair's grants without touching any task's `--prio` pin. -The Tasks tab (key 4, `#tasks/list`, `#tasks/board`, `#tasks/rasci`) shows the `kvb-org-rasci` register as a list, a board by status and a RASCI matrix; queue jobs from `council/queue.json` appear as "wartet auf Freigabe", and the filter "Wartet auf Operator" is the inbox, which the Inbox entry under Stream opens. A task's sheet pins its priority (`rasci.py set --prio `) or sets and drops the operator's WSJF estimate (`rasci.py estimate Operator --value --complexity ` or `--drop`) after a passkey signature; the hub writes an argv-only job, and the runner, started with `--rasci --council `, verifies it like an operator command and runs `rasci.py` from `/` without a shell, killing it after 30 s. Agent order stays untouched. The install copies the fresh runner unit and restarts the runner when it is enabled, and only while the installed `council.py`, `nofollow.py` and `rasci.py` match this tree: otherwise it disables the runner and asks for `make install`. The runner unit pins `PATH` to `/usr/bin:/bin`, so a signed command names any other program by its full path; a runner started without `--rasci` and `--council` keeps running signed commands and refuses task changes, and so does one whose council is a symlink or another uid's. Each worktree in the tree file may carry `"flow": {"pull": [...], "push": [...], "source": "file"}` or `null`, which the Tree, the Chord edges, the detail panel and the matching task show; a malformed flow shows as `invalid`. Worktrees and tasks with open work (uncommitted, unpushed, unmerged, task not done) carry a warning bar. +The Tasks tab (key 4, `#tasks/list`, `#tasks/board`, `#tasks/rasci`) shows the `kvb-org-rasci` register as a list, a board by status and a RASCI matrix; queue jobs from `council/queue.json` appear as "waiting for a grant", and the filter "Waiting for operator" is the inbox, which the Inbox entry under Stream opens. A task's sheet pins its priority (`rasci.py set --prio `) or sets and drops the operator's WSJF estimate (`rasci.py estimate Operator --value --complexity ` or `--drop`) after a passkey signature; the hub writes an argv-only job, and the runner, started with `--rasci --council `, verifies it like an operator command and runs `rasci.py` from `/` without a shell, killing it after 30 s. Agent order stays untouched. The install copies the fresh runner unit and restarts the runner when it is enabled, and only while the installed `council.py`, `nofollow.py` and `rasci.py` match this tree: otherwise it disables the runner and asks for `make install`. The runner unit pins `PATH` to `/usr/bin:/bin`, so a signed command names any other program by its full path; a runner started without `--rasci` and `--council` keeps running signed commands and refuses task changes, and so does one whose council is a symlink or another uid's. Each worktree in the tree file may carry `"flow": {"pull": [...], "push": [...], "source": "file"}` or `null`, which the Tree, the Chord edges, the detail panel and the matching task show; a malformed flow shows as `invalid`. Worktrees and tasks with open work (uncommitted, unpushed, unmerged, task not done) carry a warning bar. -Without reinstalling the skills, `make orchestrator-install` installs, builds and starts only the hub, `make orchestrator-check` checks the installed hub (image, container, logs, HTTP, pinned keys, hook, runner, tree timer, disk; exit 1 on a failure), `make orchestrator-pin CREDENTIAL=` pins the passkey that "Passkey registrieren" shows, `make orchestrator-runner` enables the runner service, and `make orchestrator-hook` registers the PermissionRequest hook in `~/.claude/settings.json`, replacing an earlier Agent Orchestrator entry and keeping the file mode, after a copy to `settings.json.before-kvb-orchestrator-hook` (Claude Code reads `~/.claude/settings.local.json` only in sessions started in the home directory). Agents that reach the Docker socket are root-equivalent: until the agent VMs of core requirement 093 isolate them, the signatures do not hold against such an agent. `make watch-check` shows whether the resource watch hook is stuck (running hooks, holders of the kept queue history, age of the stored stage). +Without reinstalling the skills, `make orchestrator-install` installs, builds and starts only the hub, `make orchestrator-check` checks the installed hub (image, container, logs, HTTP, pinned keys, hook, runner, tree timer, disk; exit 1 on a failure), `make orchestrator-pin CREDENTIAL=` pins the passkey that "Register passkey" shows, `make orchestrator-runner` enables the runner service, and `make orchestrator-hook` registers the PermissionRequest hook in `~/.claude/settings.json`, replacing an earlier Agent Orchestrator entry and keeping the file mode, after a copy to `settings.json.before-kvb-orchestrator-hook` (Claude Code reads `~/.claude/settings.local.json` only in sessions started in the home directory). Agents that reach the Docker socket are root-equivalent: until the agent VMs of core requirement 093 isolate them, the signatures do not hold against such an agent. `make watch-check` shows whether the resource watch hook is stuck (running hooks, holders of the kept queue history, age of the stored stage). -For approvals the hub is only a relay: every approval of an ask, a staged commit or an operator command is signed end to end with a WebAuthn passkey held in KeePassXC (through KeePassXC-Browser, relying party `localhost`, origin `http://localhost:`; ES256, EdDSA and RS256, so a hardware key can be pinned beside it). To register, open the hub at `http://localhost:/` (WebAuthn needs the domain; on `127.0.0.1` the page links there), choose "Passkey registrieren" in the settings and run the host command the page shows, `python3 ~/.local/share/kvb-orchestrator/client/approval.py pin --port --approvers ~/.config/kvb-orchestrator/approvers.json --credential ''`, in a terminal outside every sandbox: it pins the key in `~/.config/kvb-orchestrator/approvers.json` with mode 0600, a file no sandboxed agent can write and the hub mounts read-only; the hub never pins. Each approval, or one bulk selection, is one signature over the hashes of every item, a nonce and an expiry; each auto-approval rule is signed once. In the inbox, an operator command run with "Ausführen" shows the runner's output in a console under its row until "Schließen". "Ablehnen" on an ask, an operator row or a rule request signs the denial with its channel and optional reason (a hash no approval shares) and, after the 3 s undo, tells the requesting agent by post or by the radio class picked, never mayday; the hub verifies that signature against the pinned keys before it stores or sends anything, the hook passes the reason on only when it verifies the signature too, and a denied operator row ends as `stopped`. Agents ask for an auto-approval rule with the MCP tool `rule_request` (the rules form's limits; a request stays open for the ask lifetime of one hour, at most 20 in all, and 3 per agent name, which only spreads the queue since MCP names no caller); its row shows a dry run over the last 7 days, and only "Annehmen" with the passkey stores it. The hub stores no rule, of any kind, whose passkey assertion it cannot verify. The executors verify it themselves against the pinned keys and fail closed: the runner (`client/runner.py`, the `kvb-orchestrator-runner` user service) runs only signed commands, each signature once, recorded in `~/.local/state/kvb-orchestrator-approvals/runner.json`; the PermissionRequest hook (`client/permission_hook.py --port --timeout --approvers ~/.config/kvb-orchestrator/approvers.json --replay ~/.local/state/kvb-orchestrator-approvals/hook.json`) allows only a signed item that matches its own tool, command, cwd and session, else it leaves the decision to Claude Code's own prompt; the commit skills run `approval.py verify` on the staged tree before committing, else they ask in the terminal. With no key pinned, every executor refuses; decisions and review rejections stay unsigned. A signed rule never covers a command holding `;`, `&`, `|`, a backtick, `$`, `<`, `>`, parentheses or a line break: such a command always asks. The hub page is trusted while it asks for a signature or shows the blob to pin: whoever controls the hub container can show one item and have another signed, or hand over a key of its own. Any local process, sandboxed agents included, can also send the unsigned operator actions (decision choices, the priority order, settings that add no stream origin, review rejections, the bare ask denial `/api/asks//deny`, console dismissals) with the hub's guard headers, and the container reads the host `/tmp` for the review pages in `/tmp/kvb-git-diff`. All three close with the agent VMs of core requirement 093, like the Docker-socket gap. +For approvals the hub is only a relay: every approval of an ask, a staged commit or an operator command is signed end to end with a WebAuthn passkey held in KeePassXC (through KeePassXC-Browser, relying party `localhost`, origin `http://localhost:`; ES256, EdDSA and RS256, so a hardware key can be pinned beside it). To register, open the hub at `http://localhost:/` (WebAuthn needs the domain; on `127.0.0.1` the page links there), choose "Register passkey" in the settings and run the host command the page shows, `python3 ~/.local/share/kvb-orchestrator/client/approval.py pin --port --approvers ~/.config/kvb-orchestrator/approvers.json --credential ''`, in a terminal outside every sandbox: it pins the key in `~/.config/kvb-orchestrator/approvers.json` with mode 0600, a file no sandboxed agent can write and the hub mounts read-only; the hub never pins. Each approval, or one bulk selection, is one signature over the hashes of every item, a nonce and an expiry; each auto-approval rule is signed once. In the inbox, an operator command run with "Run" shows the runner's output in a console under its row until "Close". "Deny" on an ask, an operator row or a rule request signs the denial with its channel and optional reason (a hash no approval shares) and, after the 3 s undo, tells the requesting agent by post or by the radio class picked, never mayday; the hub verifies that signature against the pinned keys before it stores or sends anything, the hook passes the reason on only when it verifies the signature too, and a denied operator row ends as `stopped`. Agents ask for an auto-approval rule with the MCP tool `rule_request` (the rules form's limits; a request stays open for the ask lifetime of one hour, at most 20 in all, and 3 per agent name, which only spreads the queue since MCP names no caller); its row shows a dry run over the last 7 days, and only "Accept" with the passkey stores it. The hub stores no rule, of any kind, whose passkey assertion it cannot verify. The executors verify it themselves against the pinned keys and fail closed: the runner (`client/runner.py`, the `kvb-orchestrator-runner` user service) runs only signed commands, each signature once, recorded in `~/.local/state/kvb-orchestrator-approvals/runner.json`; the PermissionRequest hook (`client/permission_hook.py --port --timeout --approvers ~/.config/kvb-orchestrator/approvers.json --replay ~/.local/state/kvb-orchestrator-approvals/hook.json`) allows only a signed item that matches its own tool, command, cwd and session, else it leaves the decision to Claude Code's own prompt; the commit skills run `approval.py verify` on the staged tree before committing, else they ask in the terminal. With no key pinned, every executor refuses; decisions and review rejections stay unsigned. A signed rule never covers a command holding `;`, `&`, `|`, a backtick, `$`, `<`, `>`, parentheses or a line break: such a command always asks. The hub page is trusted while it asks for a signature or shows the blob to pin: whoever controls the hub container can show one item and have another signed, or hand over a key of its own. Any local process, sandboxed agents included, can also send the unsigned operator actions (decision choices, the priority order, settings that add no stream origin, review rejections, the bare ask denial `/api/asks//deny`, console dismissals) with the hub's guard headers, and the container reads the host `/tmp` for the review pages in `/tmp/kvb-git-diff`. All three close with the agent VMs of core requirement 093, like the Docker-socket gap. Restart your agent afterwards so it loads the new skills. diff --git a/docs/requirements/001-agent-orchestrator.md b/docs/requirements/001-agent-orchestrator.md index cd525db..0b6213a 100644 --- a/docs/requirements/001-agent-orchestrator.md +++ b/docs/requirements/001-agent-orchestrator.md @@ -47,27 +47,27 @@ from three views down to any agent, branch or artefact. (directory, module, container, systemd unit, MCP server, environment `KVB_ORCHESTRATOR_*`, make targets). Rejected: visible name only (two names for one thing). -10. **Navigation**: Stream (sub-items Inbox and Regeln) · Agents (ex Graph) · +10. **Navigation**: Stream (sub-items Inbox and Firewall) · Agents (ex Graph) · Artifacts (ex Tree). Agents and Artifacts each offer Orbit, Chord, Swimlane, Tree and 3D. 11. **Header**: title · ⌘K · ⚙ only. The status pills become navigation badges (Inbox: waiting items, Agents: active agents, Artifacts: runner - jobs); Mayday shows only as a red banner with "aufheben" while active; the + jobs); Mayday shows only as a red banner with "cancel" while active; the background shows day and night. Rejected: one status dot with a popover - (an extra click), a status block in a side bar, a "Lage" screen (effort), - no header at all. -12. **Tools**: Steuerung (Funk an alle, Mayday aufheben, Priorität, Tag/Nacht) - moves to the Agents toolbar, Regeln under Inbox, Himmel, Musik, - Leitstand and Benachrichtigungen to ⚙ "Ambiente"; ⌘K reaches every one. + (an extra click), a status block in a side bar, a "Situation" screen + (effort), no header at all. +12. **Tools**: Controls (Radio to all, Cancel mayday, Priority, Day/Night) + moves to the Agents toolbar, Firewall under Inbox, Sky, Music, + Control room and Notifications to ⚙ "Ambience"; ⌘K reaches every one. Rejected: one ⋯ menu (hides instead of ordering). -13. **Stream**: four category chips Für dich · Funk · Arbeit · Transkripte; - one search line with `agent:`, `art:`, `seit:`; sub-filters, saved views +13. **Stream**: four category chips For you · Radio · Work · Transcripts; + one search line with `agent:`, `kind:`, `since:`; sub-filters, saved views and a custom range under "Filter ▾"; the time bar becomes "24 h ▾" with the replay inside; transcripts are off by default. Rejected: a self-grouping stream, a Kibana-like query language (effort), preset chips only. 14. **3D**: `3d-force-graph` 1.80.1 on `three` 0.186.1, vendored as in - meta.infinito.nexus; the Canvas depth axes Zeit and Spawn-Tiefe become 3D + meta.infinito.nexus; the Canvas depth axes Time and Spawn depth become 3D options. Rejected: keeping the Orbit-only Canvas depth. 15. **Artifacts scope**: git (repositories → branches → worktrees with their agents and reviews) plus the kvb-org-rasci register artefacts (images, @@ -99,8 +99,7 @@ from three views down to any agent, branch or artefact. locked, stale, protected and the gc skip reason. The Artifacts Tree shows it as icons. Phase 3 builds the data, phase 4 the icons. 21. **Delete from the tree**: merged, orphaned branches are deleted by click - in the Artifacts Tree (phase 4), per item and as "Alle gemergten - löschen": + in the Artifacts Tree (phase 4), per item and as "Delete all merged": - **Credentials**: only while the Secret Service hands pkgmgr the GitHub token, which proves the merge and the missing open pull request; no secret passes the orchestrator container. Rejected: the master password @@ -115,7 +114,7 @@ from three views down to any agent, branch or artefact. `pkgmgr branch gc --apply` deletes today (remote branch and `compose down -v`). - **Confirmation**: the click shows the gc dry-run lines of the chosen - items, and "Löschen" needs the operator signature (`/api/sign`). + items, and "Delete" needs the operator signature (`/api/sign`). Rejected: a second click without signature, one click without preview. - **Execution**: the orchestrator writes a signed job into a host directory; a systemd user path unit runs `pkgmgr branch cleanup --apply @@ -125,19 +124,19 @@ from three views down to any agent, branch or artefact. and client which skills changed and how to use them, as one `newsletter` per update; phase 1 announces the radio change through it. 23. **Phase 5** (23 to 43 operator-confirmed 2026-11-07): the console - output shows under "Ausführen" (Run); a deny picks its channel (default + output shows under "Run"; a deny picks its channel (default `post`); agents request auto-approval rules through the - inbox; the rules form and the Ort fields never overlap; the radio plays + inbox; the rules form and the Location fields never overlap; the radio plays with one line per station and highlights the speaking agent; the operator composer sends text or voice, recorded, transcribed locally with whisper in the container and kept as audio, to a recipient by `post` or - `call`; a Hierarchie view shows the council offices with appoint and + `call`; a Hierarchy view shows the council offices with appoint and recall; the agent order (drag list) is separate from task priority (WSJF plus the operator's pin) and only breaks ties; one Tasks tab holds list, board and RASCI matrix, the inbox as its "waits on Operator" filter and the queue state; the merge flow, a pkgmgr-managed YAML per worktree with several pull sources and push targets, shows in Artifacts and Tasks. -24. **Firewall**: the tab Regeln becomes Firewall and holds every form of +24. **Firewall**: the rules tab becomes Firewall and holds every form of allow-listing: the hub's auto-approval rules (ask, review, decision), allow and deny command patterns, and the Claude settings permissions (`allow`, `ask`, `deny`) and sandbox entries. Rejected: a separate @@ -168,7 +167,7 @@ from three views down to any agent, branch or artefact. `kvb-org-evening` → `kvb-org-drain`, `kvb-org-sunset` → `kvb-org-suspend`, `kvb-org-sunrise` → `kvb-org-resume`, `kvb-agent-relax` → `kvb-agent-drain`, `kvb-agent-sleep` → `kvb-agent-suspend`, - `kvb-agent-wakeup` → `kvb-agent-resume`; `night.py` and the Steuerung + `kvb-agent-wakeup` → `kvb-agent-resume`; `night.py` and the Controls menu follow, `kvb-skill-cleanup` removes the old names. Rejected: sleep / hibernate / wakeup, pause / park / resume. 30. **Agent popup**: a click on an agent opens a fading popup with a simple, @@ -196,7 +195,7 @@ from three views down to any agent, branch or artefact. 36. **Tree cause**: the tree timer builds pkgmgr from the newest signed tag, and v2.3.0 has no `branch tree`, so no tree file exists. The Tree names that cause and the operator step (the pkgmgr release) instead of a bare - "Kein Tree"; with pkgmgr 2.4.0 released the timer writes the file. + "No tree"; with pkgmgr 2.4.0 released the timer writes the file. 37. **Resources**: a tab Resources shows charts on the shared time axis: tokens per agent and accumulated (from the usage fields of the session transcripts), and CPU, RAM, disk and load of the host, sampled by a host @@ -324,7 +323,7 @@ Phases 5 and 6 (decisions 23 to 42): ```mermaid flowchart TD - subgraph W["🧩 5 · Inbox, UI, Hierarchie, Tasks"] + subgraph W["🧩 5 · Inbox, UI, Hierarchy, Tasks"] W1["🛠️ W1 to W4 in own worktrees"] --> W2["🕵️ Skeptic round, fix round per worktree"] W2 --> W3{"🧪 Suite, e2e, MEDUSA, score green?"} W3 -- "🔴 no: fix" --> W2 @@ -422,7 +421,7 @@ flowchart TD `kvb-orchestrator` names. A second run changes nothing (scratch-HOME test). - [ ] The navigation has exactly three top-level entries Stream, Agents and - Artifacts; Stream has the sub-items Inbox and Regeln. + Artifacts; Stream has the sub-items Inbox and Firewall. - [ ] Every agent appears once under its current name: a register worker such as "Stage (this session)" or "infinito-nexus-core-c8 (Production)" maps to the agent named before the bracket. @@ -438,18 +437,18 @@ flowchart TD - [ ] Agents shows the agents with a heartbeat in the last 900 s. - [ ] Artifacts shows the runner jobs that are queued or running. - [ ] A badge at 0 is hidden. -- [ ] A red Mayday banner with "aufheben" exists if and only if a mayday is - active; "aufheben" runs `radio.py clear`. +- [ ] A red Mayday banner with "cancel" exists if and only if a mayday is + active; "cancel" runs `radio.py clear`. - [ ] The Agents toolbar holds: - - [ ] Funk an alle, with the class choice Newsletter, Broadcast, Pan-Pan, + - [ ] Radio to all, with the class choice Newsletter, Broadcast, Pan-Pan, Security, Mayday and Newsletter preselected. - - [ ] Mayday aufheben, Priorität and Tag/Nacht. + - [ ] Cancel mayday, Priority and Day/Night. - [ ] The agent panel sends with the choice Post (preselected) or Call. -- [ ] ⚙ "Ambiente" holds Himmel, Musik, Leitstand and Benachrichtigungen; +- [ ] ⚙ "Ambience" holds Sky, Music, Control room and Notifications; ⌘K lists every former header tool. -- [ ] The Stream shows exactly four category chips Für dich, Funk, Arbeit and - Transkripte, and one search line that filters by `agent:`, `art:` and - `seit:`. +- [ ] The Stream shows exactly four category chips For you, Radio, Work and + Transcripts, and one search line that filters by `agent:`, `kind:` and + `since:`. - [ ] "Filter ▾" holds the kind sub-filters, the transcript parts, the saved views and the custom range. - [ ] The time control reads "24 h ▾" and holds the replay. @@ -515,7 +514,7 @@ flowchart TD - [ ] 3D in both tabs runs on the vendored `3d-force-graph` 1.80.1 and `three` 0.186.1, with their MIT licence texts beside them and no CDN request (CSP unchanged). -- [ ] 3D offers the layouts Kraft, Zeit and Spawn-Tiefe. +- [ ] 3D offers the layouts Force, Time and Spawn depth. - [ ] A click on a 3D node opens the same panel as in 2D. - [ ] 3D respects `prefers-reduced-motion`. @@ -525,10 +524,10 @@ flowchart TD merged (with what merged it), clean, uncommitted changes (with counts), unpushed commits, gone upstream, locked, stale and protected. - [ ] A `merged-clean` item without a gc skip reason shows a delete button, - and the Tree header shows "Alle gemergten löschen"; both are disabled, + and the Tree header shows "Delete all merged"; both are disabled, with the reason as tooltip, while `delete_ready` is false. - [ ] A click shows the gc dry-run lines of exactly the chosen items; - "Löschen" requires the operator signature through `/api/sign`. + "Delete" requires the operator signature through `/api/sign`. - [ ] The orchestrator writes the signed job (repository, branch, worktree and tip sha per item, no command) into a host-mounted job directory and holds no git, token or key. @@ -555,7 +554,7 @@ flowchart TD - [ ] Every icon element has a `title` and an `aria-label` that carry the former text (DOM test over every page). -### Phase 5: inbox, UI, Hierarchie, Tasks +### Phase 5: inbox, UI, Hierarchy, Tasks - [ ] A deny is refused by the hub unless its passkey proof verifies; the PermissionRequest hook quotes a deny reason only when it verifies. @@ -570,12 +569,12 @@ flowchart TD ### Phase 6: English and radio speech (S0) -- [ ] The text handed to the speech engine for a `security` row starts with +- [x] The text handed to the speech engine for a `security` row starts with "say-cure-ee-tay" three times; the page shows "Sécurité". -- [ ] `8e180be` is spoken "eight echo one eight zero bravo echo" and +- [x] `8e180be` is spoken "eight echo one eight zero bravo echo" and `42305` "four two tree zero fife" (unit test on the pronunciation step); the displayed line is unchanged. -- [ ] A scan of the tree finds no German UI, message or document text +- [x] A scan of the tree finds no German UI, message or document text outside quoted trigger phrases (test with an allowlist of those phrases). @@ -615,7 +614,7 @@ flowchart TD `kvb-agent-drain`, `kvb-agent-suspend` and `kvb-agent-resume` exist; the old six names exist nowhere in the tree except in the migration and `kvb-skill-cleanup` history (grep test). -- [ ] The Steuerung menu shows Drain, Suspend and Resume and each needs the +- [ ] The Controls menu shows Drain, Suspend and Resume and each needs the passkey, like the board actions today. ### Phase 6: Tasks with asks and choices (S5) @@ -716,7 +715,7 @@ flowchart TD them. - [ ] `make test` green on the commit of each phase. - **E2E** - - [ ] A headless Chromium and Firefox run opens Stream, Inbox, Regeln and + - [ ] A headless Chromium and Firefox run opens Stream, Inbox, Firewall and every view of Agents and Artifacts at 1920, 1366 and 390 px wide and saves the screenshots shown at each operator checkpoint. - [ ] It sends a Call from the agent panel and sees its receipt in the diff --git a/orchestrator/client/signing.py b/orchestrator/client/signing.py index f4d2869..260fd44 100644 --- a/orchestrator/client/signing.py +++ b/orchestrator/client/signing.py @@ -30,13 +30,13 @@ COMMANDS = "operator/" APPROVAL_KEYS = {"v", "kind", "items", "nonce", "expires"} RULE_KEYS = {"v", "kind", "id", "kinds", "tool", "pattern", "scope", "expires"} WARNINGS = ( - ("löscht rekursiv", re.compile(r"\brm\s+(?:-\S+\s+)*-\S*[rR]")), - ("erzwingt", re.compile(r"--force\b|\bpush\b.*\s-f\b")), - ("pusht", re.compile(r"\bgit\b.*\bpush\b")), + ("deletes recursively", re.compile(r"\brm\s+(?:-\S+\s+)*-\S*[rR]")), + ("forces", re.compile(r"--force\b|\bpush\b.*\s-f\b")), + ("pushes", re.compile(r"\bgit\b.*\bpush\b")), ("root", re.compile(r"\bsudo\b|\bdoas\b")), - ("Pipe in eine Shell", re.compile(r"\|\s*(?:sudo\s+)?(?:ba|z|k|da)?sh\b")), - ("verwirft Änderungen", re.compile(r"\bgit\b.*\b(?:reset\s+--hard|clean\s+-\S*f)")), - ("Docker löscht", re.compile(r"\bdocker\s+(?:system\s+prune|volume\s+(?:rm|prune)|rmi?\b)")), + ("pipes into a shell", re.compile(r"\|\s*(?:sudo\s+)?(?:ba|z|k|da)?sh\b")), + ("discards changes", re.compile(r"\bgit\b.*\b(?:reset\s+--hard|clean\s+-\S*f)")), + ("Docker deletes", re.compile(r"\bdocker\s+(?:system\s+prune|volume\s+(?:rm|prune)|rmi?\b)")), ) diff --git a/orchestrator/kvb_orchestrator/approving.py b/orchestrator/kvb_orchestrator/approving.py index 801617a..68ccf7e 100644 --- a/orchestrator/kvb_orchestrator/approving.py +++ b/orchestrator/kvb_orchestrator/approving.py @@ -81,7 +81,7 @@ class Approving: try: verifier.check(proof, item, "", trust, time.time()) except signing.Refused as error: - raise ToolError(f"nicht signiert: {error}") from None + raise ToolError(f"not signed: {error}") from None return proof def still_signed(self, proof: dict, item: dict) -> None: @@ -94,7 +94,7 @@ class Approving: raise signing.Refused("the signature does not list this item") passkey.verify_assertion(proof["assertion"], proof["payload"], verifier.pinned(self.approvers), signing.origin_of(self.public_port)) except signing.Refused as error: - raise ToolError(f"nicht signiert: {error}") from None + raise ToolError(f"not signed: {error}") from None def covered(self, proof: object, signed: list[dict], now: float) -> dict | None: """Args: @@ -112,7 +112,7 @@ class Approving: raise ToolError("proof must be null when no item needs a signature") return None if not isinstance(proof, dict): - raise ToolError("nicht signiert: an approval of an ask, review or operator command needs the passkey signature") + raise ToolError("not signed: an approval of an ask, review or operator command needs the passkey signature") expect(proof, ("payload", "assertion")) try: payload = signing.checked_approval(proof["payload"], now) @@ -136,15 +136,15 @@ class Approving: item = {"kind": kind_name, "id": record["id"], "verb": "approve", "label": record.get("recommended", ""), "sha256": "", "title": shown(title)[:200], "gate": record.get("gate", ""), "signed": signed, "note": None} batch = self.batches.add([item], f"rule:{rule['id']}", rule.get("proof"), self.apply) words = f"{rule['kind']} {rule['tool']} {rule['pattern']}".replace(" ", " ") - self.log.add({"kind": "rule", "title": f"Regel gibt frei: {item['title']}", "text": words, "ref": {"rule": rule["id"], "batch": batch["id"], "item": item["id"]}}) + self.log.add({"kind": "rule", "title": f"Rule grants: {item['title']}", "text": words, "ref": {"rule": rule["id"], "batch": batch["id"], "item": item["id"]}}) def apply(self, batch: dict) -> None: for item in batch["items"]: try: outcome = self.settle_item(item, batch["proof"] if item["signed"] is not None else None) except (OSError, ToolError) as error: - outcome = f"fehlgeschlagen: {error}" - verb = "Freigabe" if item["verb"] == "approve" else "Ablehnung" + outcome = f"failed: {error}" + verb = "Grant" if item["verb"] == "approve" else "Denial" label = f" → {item['label']}" if item["label"] else "" ref = {"kind": item["kind"], "id": item["id"], "verb": item["verb"], "source": batch["source"], "outcome": outcome} self.log.add({"kind": "approval", "title": f"{verb} {item['kind']}: {item['title']}{label}", "text": f"{outcome} ({batch['source']})", "ref": ref}) @@ -158,15 +158,15 @@ class Approving: if item["kind"] == "ask": record = self.asks.get(item["id"]) if record is None or ask_state(record, time.time())["status"] == "expired": - return "abgelaufen" + return "expired" record, changed = self.asks.decide(item["id"], {"status": "allowed" if approve else "denied", "proof": proof}) elif item["kind"] == "review": record, changed = self.reviews.decide(item["id"], {"status": "approved" if approve else "rejected", "proof": proof}) else: record, changed = self.decisions.decide(item["id"], {"status": "decided", "choice": item["label"]}) if record is None: - return "unbekannt" - return record["status"] if changed else f"schon {record['status']}" + return "unknown" + return record["status"] if changed else f"already {record['status']}" def requester(self, raw: dict, who: str) -> str: """Returns: @@ -216,7 +216,7 @@ class Approving: raise ToolError("a decision is approved with one of its option labels") label = raw["label"] if kind_name == "rule": - return inbox_item(raw, "", f"Regel {request_words(record)}", "", request_signed(record), self.requester(raw, record["agent"])) + return inbox_item(raw, "", f"Rule {request_words(record)}", "", request_signed(record), self.requester(raw, record["agent"])) title = {"review": record.get("title"), "ask": f"{record.get('tool')} {record.get('command')}", "decision": record.get("question")}[kind_name] subject = {"review": review_signed, "ask": ask_signed}[kind_name](record) if kind_name != "decision" else None return inbox_item(raw, label, title, record.get("gate", ""), subject, self.requester(raw, record["session"] if kind_name == "ask" else "")) @@ -259,5 +259,5 @@ class Approving: def undo(self, batch_id: str) -> dict: batch = self.batches.undo(batch_id) titles = ", ".join(item["title"][:80] for item in batch["items"]) - self.log.add({"kind": "approval", "title": f"Rückgängig: {titles}", "text": batch["source"], "ref": {"batch": batch_id}}) + self.log.add({"kind": "approval", "title": f"Undone: {titles}", "text": batch["source"], "ref": {"batch": batch_id}}) return {"id": batch_id, "status": "undone"} diff --git a/orchestrator/kvb_orchestrator/cleanup.py b/orchestrator/kvb_orchestrator/cleanup.py index eade53e..6cdb85f 100644 --- a/orchestrator/kvb_orchestrator/cleanup.py +++ b/orchestrator/kvb_orchestrator/cleanup.py @@ -71,7 +71,7 @@ class Cleaning: raise ToolError(f"items must be a list of 1 to {ITEM_LIMIT} objects") scan = self.tree.get() if scan.get("delete_ready") is not True: - raise ToolError(f"löschen gesperrt: {scan.get('delete_reason') or scan.get('error') or 'delete_ready ist false'}") + raise ToolError(f"delete blocked: {scan.get('delete_reason') or scan.get('error') or 'delete_ready is false'}") known = offered(scan) chosen = [] for entry in raw: @@ -94,7 +94,7 @@ class Cleaning: job = {"v": JOB_VERSION, "id": job_id, "created": stamp(), "items": [{key: item[key] for key in JOB_KEYS} for item in items], "proof": proof} self.spool.put(job_id, job) names = ", ".join(item["branch"] for item in items) - self.log.add({"kind": "run", "title": f"Löschen signiert: {names}"[:200], "text": "\n".join(f"{item['repository']} {item['branch']} @ {item['tip'][:12]}" for item in items), "ref": {"cleanup": job_id, "status": "queued"}}) + self.log.add({"kind": "run", "title": f"Delete signed: {names}"[:200], "text": "\n".join(f"{item['repository']} {item['branch']} @ {item['tip'][:12]}" for item in items), "ref": {"cleanup": job_id, "status": "queued"}}) return {"id": job_id, "status": "queued", "items": job["items"]} def cleanup_state(self, job_id: str) -> dict: diff --git a/orchestrator/kvb_orchestrator/crons.py b/orchestrator/kvb_orchestrator/crons.py index a5b907d..04240e5 100644 --- a/orchestrator/kvb_orchestrator/crons.py +++ b/orchestrator/kvb_orchestrator/crons.py @@ -9,7 +9,7 @@ from .records import epoch, read_json, shown CRON_ACTIVE = 900 TIMER_KEYS = ("OnCalendar", "OnActiveSec", "OnBootSec", "OnStartupSec", "OnUnitActiveSec", "OnUnitInactiveSec") -CRON_LABELS = {"cron": "Cron", "wakeup": "Wakeup", "background": "Hintergrund", "timer": "Timer", "queue": "Queue"} +CRON_LABELS = {"cron": "Cron", "wakeup": "Wakeup", "background": "Background", "timer": "Timer", "queue": "Queue"} def cron_state(cron: dict, beats: dict[str, float], now: float) -> dict: @@ -59,7 +59,7 @@ def queue_entries(council: Path) -> list[tuple[dict, float]]: def queue_rows(council: Path) -> list[dict]: rows = [] for entry, created in queue_entries(council): - running = "läuft" if entry.get("status") == "active" else "wartet" + running = "running" if entry.get("status") == "active" else "waiting" rows.append({ "key": f"queue:{shown(entry.get('id'))}", "type": "queue", "session": shown(entry.get("session")), "sub": "", "created": created, "deleted": None, "until": None, "job": shown(entry.get("id")), "expression": f"{shown(entry.get('kind'))} · {running}", diff --git a/orchestrator/kvb_orchestrator/denying.py b/orchestrator/kvb_orchestrator/denying.py index 0867b14..5958f84 100644 --- a/orchestrator/kvb_orchestrator/denying.py +++ b/orchestrator/kvb_orchestrator/denying.py @@ -76,28 +76,28 @@ class Denying: tasks = read_register(self.council / REGISTER) row = next((row for row in operator_rows(tasks) if row["task"] == item["id"]), None) if row is None or signing.denial_item(operator_signed(row), note["channel"], note["reason"], note["to"]) != item["signed"]: - return "verweigert: die Zeile hat sich seit der Ablehnung geändert" + return "refused: the row changed since the denial" if item["id"] in self.open_jobs(): - return "läuft schon" + return "already running" run = self.scripts.run(RASCI, ["set", item["id"], "--status", "stopped"]) if run["code"] != 0: - return f"fehlgeschlagen: {run['command']} → {run['code']}" + return f"failed: {run['command']} → {run['code']}" command, directory = row["command"][:200], row["directory"] - return f"gestoppt · {self.tell(item, proof, adder(tasks[item['id']]), f'operator command {command} in {directory}')}" + return f"stopped · {self.tell(item, proof, adder(tasks[item['id']]), f'operator command {command} in {directory}')}" ledger = self.asks if item["kind"] == "ask" else self.rule_requests record = ledger.get(item["id"]) if record is None: - return "unbekannt" + return "unknown" now = time.time() if (ask_state(record, now)["status"] if item["kind"] == "ask" else request_status(record, now)) == "expired": - return "abgelaufen" + return "expired" record, changed = ledger.decide(item["id"], {"status": "denied", "proof": proof, **note}) if not changed: - return f"schon {record['status']}" + return f"already {record['status']}" if item["kind"] == "ask": tool, command = record["tool"], record["command"][:200] - return f"abgelehnt · {self.tell(item, proof, record['session'], f'ask {tool}: {command}')}" - return f"abgelehnt · {self.tell(item, proof, record['agent'], f'rule request {request_words(record)}')}" + return f"denied · {self.tell(item, proof, record['session'], f'ask {tool}: {command}')}" + return f"denied · {self.tell(item, proof, record['agent'], f'rule request {request_words(record)}')}" def addressee(self, who: str) -> tuple[str, str]: return requester_of(read_claims(self.council), who) @@ -120,11 +120,11 @@ class Denying: direct = channel in DIRECT address = self.addressee(note["to"])[1] if direct else EVERYONE if direct and not address: - return f"kein Empfänger für {channel}" + return f"no recipient for {channel}" text = denial_text(what, self.addressee(who)[0], note["reason"]) - where = f"{channel} an {address}" if direct else f"{channel} an alle" + where = f"{channel} to {address}" if direct else f"{channel} to all" fields = {"to": note["to"], "address": address, "text": text, "upload": None, "voice": None, "voice_sha256": "", "class": channel} record = self.messages.add({**fields, "denial": item["signed"], "proof": proof, "created_ts": time.time()}) targets = ["--to", address] if direct else [] run = self.scripts.run(RADIO, [*DENY_CHANNELS[channel], *targets, "--session", HUMAN, f"[kvb-orchestrator msg {record['id']}] {' '.join(text.split())}"]) - return where if run["code"] == 0 else f"{where} fehlgeschlagen ({run['code']})" + return where if run["code"] == 0 else f"{where} failed ({run['code']})" diff --git a/orchestrator/kvb_orchestrator/events.py b/orchestrator/kvb_orchestrator/events.py index a7ea702..3cc4ff6 100644 --- a/orchestrator/kvb_orchestrator/events.py +++ b/orchestrator/kvb_orchestrator/events.py @@ -17,18 +17,18 @@ from .register import status_of from .transcripts import LOG_KEEP, STREAM_CUT, STREAM_KINDS KINDS = ( - ("radio", "Funk"), ("review", "Reviews"), ("ask", "Asks"), ("decision", "Entscheidungen"), ("operator", "Operator"), ("register", "Register"), - ("rename", "Namen"), ("cron", "Crons"), ("rule", "Regeln"), ("approval", "Freigaben"), ("run", "Runner"), ("transcript", "Transkripte"), + ("radio", "Radio"), ("review", "Reviews"), ("ask", "Asks"), ("decision", "Decisions"), ("operator", "Operator"), ("register", "Register"), + ("rename", "Names"), ("cron", "Crons"), ("rule", "Firewall"), ("approval", "Grants"), ("run", "Runner"), ("transcript", "Transcripts"), ) EVENT_KINDS = tuple(name for name, _ in KINDS) WORK = [name for name in EVENT_KINDS if name not in ("radio", "transcript")] VIEWS = { - "fuer-dich": {"label": "Für dich", "kinds": ["radio", *WORK], "waiting": True}, - "funk": {"label": "Funk", "kinds": ["radio"], "waiting": False}, - "arbeit": {"label": "Arbeit", "kinds": WORK, "waiting": False}, - "transkripte": {"label": "Transkripte", "kinds": ["transcript"], "waiting": False}, + "fuer-dich": {"label": "For you", "kinds": ["radio", *WORK], "waiting": True}, + "funk": {"label": "Radio", "kinds": ["radio"], "waiting": False}, + "arbeit": {"label": "Work", "kinds": WORK, "waiting": False}, + "transkripte": {"label": "Transcripts", "kinds": ["transcript"], "waiting": False}, } -ART = {word: name for name, label in KINDS for word in (name, label.lower())} +KIND_WORDS = {word: name for name, label in KINDS for word in (name, label.lower())} SPAN = re.compile(r"(\d{1,4})([mhd])") UNITS = {"m": 60, "h": 3600, "d": 86400} @@ -44,14 +44,14 @@ def since_of(word: str, now: float) -> float: try: return datetime.datetime.fromisoformat(word).timestamp() except ValueError: - raise ToolError("seit: takes 30m, 2h, 3d or a date like 2026-11-06 or 2026-11-06T08:30") from None + raise ToolError("since: takes 30m, 2h, 3d or a date like 2026-11-06 or 2026-11-06T08:30") from None def search(text: str, now: float) -> dict: """Args: - text: the search line: words, `agent:`, `art:` - and `seit:`. - now: the clock `seit:` spans count back from. + text: the search line: words, `agent:`, `kind:` + and `since:`. + now: the clock `since:` spans count back from. Returns: The plain words as `q`, plus `agent`, `kinds` and `since` for each @@ -60,16 +60,16 @@ def search(text: str, now: float) -> dict: found: dict = {"q": []} for word in text.split(): key, colon, value = word.partition(":") - if not colon or key not in ("agent", "art", "seit"): + if not colon or key not in ("agent", "kind", "since"): found["q"].append(word) elif not value: raise ToolError(f"{key}: needs a value") elif key == "agent": found["agent"] = value - elif key == "art": - if value.lower() not in ART: - raise ToolError(f"art: takes one of {', '.join(EVENT_KINDS)}") - found.setdefault("kinds", set()).add(ART[value.lower()]) + elif key == "kind": + if value.lower() not in KIND_WORDS: + raise ToolError(f"kind: takes one of {', '.join(EVENT_KINDS)}") + found.setdefault("kinds", set()).add(KIND_WORDS[value.lower()]) else: found["since"] = since_of(value, now) found["q"] = " ".join(found["q"]).lower() @@ -128,7 +128,7 @@ def register_changes(before: dict[str, dict], after: dict[str, dict], now: float continue if old is None or new is None: row = new if old is None else old - change = f"neu: {shown(row.get('title'))}" if old is None else "entfernt" + change = f"new: {shown(row.get('title'))}" if old is None else "removed" else: keys = sorted(key for key in set(old) | set(new) if old.get(key) != new.get(key)) change = "; ".join(f"{key}: {described(old.get(key))} → {described(new.get(key))}" for key in keys) diff --git a/orchestrator/kvb_orchestrator/jobs.py b/orchestrator/kvb_orchestrator/jobs.py index 6270863..dd4876b 100644 --- a/orchestrator/kvb_orchestrator/jobs.py +++ b/orchestrator/kvb_orchestrator/jobs.py @@ -54,12 +54,12 @@ class Jobs: def queue_job(self, item: dict, proof: dict | None) -> str: row = next((row for row in operator_rows(read_register(self.council / REGISTER)) if row["task"] == item["id"]), None) if row is None or not runnable(row) or operator_signed(row) != item["signed"]: - return "verweigert: die Zeile hat sich seit der Freigabe geändert" + return "refused: the row changed since the grant" if item["id"] in self.open_jobs(): - return "läuft schon" + return "already running" job = {"task": row["task"], "command": row["command"], "directory": row["directory"], "sha256": item["sha256"], "status": "queued", "proof": proof} self.jobs.add({**job, "code": None, "output": "", "created_ts": time.time(), "started": None, "finished": None, "dismissed": False}) - return "an den Runner übergeben" + return "handed to the runner" def runner_jobs(self) -> dict: return {"jobs": [runner_job(job) for job in self.jobs.listed() if job["status"] == "queued"]} diff --git a/orchestrator/kvb_orchestrator/language.py b/orchestrator/kvb_orchestrator/language.py index 5e8382b..8259d56 100644 --- a/orchestrator/kvb_orchestrator/language.py +++ b/orchestrator/kvb_orchestrator/language.py @@ -87,36 +87,36 @@ def nl_action(raw: object, items: dict[str, dict], agents: list[str]) -> dict: raise ToolError("that operator row holds no command to run") chosen = [nl_item(item, "approve" if name == "approve" else "reject", item["recommended"] if item["kind"] == "decision" else "") for item in picked] lines = [f"{item['kind']} {item['id']}: {item['command'] if item['kind'] == 'operator' else item['title']}" for item in picked] - verb = "Freigeben" if name == "approve" else "Ablehnen" + verb = "Grant" if name == "approve" else "Deny" return {"name": name, "summary": f"{verb}:\n" + "\n".join(lines), "args": {"items": chosen}} if name == "choose": item = items.get(arguments["id"]) if isinstance(arguments["id"], str) else None if item is None or item["kind"] != "decision" or arguments["label"] not in [option["label"] for option in item["options"]]: raise ToolError("choose takes a decision id and one of its option labels") - return {"name": name, "summary": f"Entscheiden: {item['title']} → {arguments['label']}", "args": {"items": [nl_item(item, "approve", arguments["label"])]}} + return {"name": name, "summary": f"Decide: {item['title']} → {arguments['label']}", "args": {"items": [nl_item(item, "approve", arguments["label"])]}} if name in ("snooze", "pin"): picked = nl_ids(arguments, items) hours = arguments.get("hours") if name == "snooze" and (isinstance(hours, bool) or not isinstance(hours, int | float) or not 1 <= hours <= 192): raise ToolError("hours must be between 1 and 192") keys = [{"kind": item["kind"], "id": item["id"]} for item in picked] - words = f"Zurückstellen ({hours} h)" if name == "snooze" else "Anheften" + words = f"Snooze ({hours} h)" if name == "snooze" else "Pin" return {"name": name, "summary": f"{words}: " + ", ".join(item["title"][:80] for item in picked), "args": {"keys": keys, "hours": hours}} if name == "view": if arguments["name"] not in VIEWS: raise ToolError("unknown view") - return {"name": name, "summary": f"Ansicht: {VIEWS[arguments['name']]['label']}", "args": {"name": arguments["name"]}} + return {"name": name, "summary": f"View: {VIEWS[arguments['name']]['label']}", "args": {"name": arguments["name"]}} if name == "open": if arguments["view"] not in SCREENS: raise ToolError("unknown screen") - return {"name": name, "summary": f"Öffnen: {arguments['view']}", "args": {"view": arguments["view"]}} + return {"name": name, "summary": f"Open: {arguments['view']}", "args": {"view": arguments["view"]}} if name == "message": text = message_text(arguments, "text") if arguments["to"] not in agents: raise ToolError("to must name a known agent") - return {"name": name, "summary": f"Funk an {arguments['to']}: {text}", "args": {"to": arguments["to"], "text": text}} + return {"name": name, "summary": f"Radio to {arguments['to']}: {text}", "args": {"to": arguments["to"], "text": text}} query = bounded(arguments, "q", 200) - return {"name": name, "summary": f"Suchen: {query}", "args": {"q": query}} + return {"name": name, "summary": f"Search: {query}", "args": {"q": query}} def nl_actions(reply: str, items: list[dict], agents: list[str]) -> dict: diff --git a/orchestrator/kvb_orchestrator/names.py b/orchestrator/kvb_orchestrator/names.py index 04531ba..43e1fbf 100644 --- a/orchestrator/kvb_orchestrator/names.py +++ b/orchestrator/kvb_orchestrator/names.py @@ -75,8 +75,8 @@ class Directory: if begin <= after["first_seen"] <= end: found.append(event({ "id": f"rename:{session}:{after['first_seen']}", "ts": after["first_seen"], "kind": "rename", "agent": after["name"], - "now": self.now(session), "session": session, "title": f"{before['name']} heißt jetzt {after['name']}", - "text": f"Quelle: {after['source']}", "ref": {"before": before["name"], "after": after["name"], "source": after["source"]}, + "now": self.now(session), "session": session, "title": f"{before['name']} is now called {after['name']}", + "text": f"Source: {after['source']}", "ref": {"before": before["name"], "after": after["name"], "source": after["source"]}, })) return found diff --git a/orchestrator/kvb_orchestrator/offices.py b/orchestrator/kvb_orchestrator/offices.py index b2421ec..adb6aff 100644 --- a/orchestrator/kvb_orchestrator/offices.py +++ b/orchestrator/kvb_orchestrator/offices.py @@ -11,7 +11,7 @@ from .signed import signing ITEM_LIMIT = 20 JOB_VERSION = 1 -LABELS = {"appoint": "besetzt", "takeover": "übergeben", "recall": "abberufen"} +LABELS = {"appoint": "appointed", "takeover": "handed over", "recall": "recalled"} def office_request(raw: object) -> bool: @@ -77,7 +77,7 @@ class Offices: self.office_spool.put(job_id, job) names = ", ".join(f"{item['office']} {LABELS[item['action']]}" for item in items) lines = "\n".join(f"{item['action']} {item['office']}: {item['holder'] or '-'} -> {item['session'] or '-'}" for item in items) - self.log.add({"kind": "run", "title": f"Amt signiert: {names}"[:200], "text": lines, "ref": {"offices": job_id, "status": "queued"}}) + self.log.add({"kind": "run", "title": f"Office signed: {names}"[:200], "text": lines, "ref": {"offices": job_id, "status": "queued"}}) return {"id": job_id, "status": "queued", "items": job["items"]} def office_state(self, job_id: str) -> dict: diff --git a/orchestrator/kvb_orchestrator/phrasing.py b/orchestrator/kvb_orchestrator/phrasing.py index 6d5e1c7..a2375bc 100644 --- a/orchestrator/kvb_orchestrator/phrasing.py +++ b/orchestrator/kvb_orchestrator/phrasing.py @@ -8,16 +8,38 @@ SPEECH_LIMIT = 1000 SPOKEN_TEXT = 500 SPOKEN_NAME = 60 SPOKEN_GROUP = 120 -ALARM_WORDS = {"pan-pan": "PAN-PAN", "security": "SECURITE"} +ALARM_WORDS = {"pan-pan": "PAN-PAN", "security": "say-cure-ee-tay"} ADDRESSED = ("post", "call", "receipt") CALLS = re.compile(r"^(?:(?:MAYDAY|PAN[ -]?PAN|SECURIT[EÉY])\b[\s:,.;!-]*)+", re.IGNORECASE) HUB_MARK = re.compile(r"\[kvb-orchestrator msg [0-9a-f]{16}\]") HUB_FILE = re.compile(r"\s+file: /\S*$") SPOKEN_LINE = re.compile(LINE.format(SPEECH_LIMIT)) +HASH = re.compile(r"\b(?=[0-9a-f]*[a-f])(?=[0-9a-f]*[0-9])[0-9a-f]{7,}\b|[0-9]", re.IGNORECASE) +NATO = dict(zip("abcdef", ("alfa", "bravo", "charlie", "delta", "echo", "foxtrot"))) +ICAO = dict(zip("0123456789", ("zero", "one", "two", "tree", "four", "fife", "six", "seven", "eight", "niner"))) + + +def pronounced(text: str) -> str: + """Args: + text: a radio text as displayed. + + Returns: + The text with each hex run of 7 or more characters holding a letter + and a digit spelled in the NATO alphabet and every other digit + spoken on its own in ICAO pronunciation. + """ + return HASH.sub(spelled, text) + + +def spelled(found: re.Match) -> str: + start, end = found.span() + before = " " if start and found.string[start - 1].isalnum() else "" + after = " " if end < len(found.string) and found.string[end].isalnum() else "" + return before + " ".join(NATO.get(char) or ICAO[char] for char in found[0].lower()) + after def clip(text: str, limit: int) -> str: - words = " ".join(text.split()) + words = " ".join(pronounced(text).split()) if len(words) <= limit: return words return words[:limit].rsplit(" ", 1)[0] or words[:limit] diff --git a/orchestrator/kvb_orchestrator/requesting.py b/orchestrator/kvb_orchestrator/requesting.py index 5db7cf7..452ba22 100644 --- a/orchestrator/kvb_orchestrator/requesting.py +++ b/orchestrator/kvb_orchestrator/requesting.py @@ -49,7 +49,7 @@ class Requesting: raise ToolError(f"{name} already has {AGENT_CAP} pending rule requests; wait for their answer with rule_request_wait") record = self.rule_requests.add_checked({**fields, "agent": name, "why": why, "status": "pending", "rule": None, "reason": "", "channel": "", "proof": None, "decided": None, "created_ts": now}, capped) - self.log.add({"kind": "rule", "title": f"Regelwunsch von {name}: {request_words(record)}", "text": why, "ref": {"request": record["id"]}}) + self.log.add({"kind": "rule", "title": f"Rule request from {name}: {request_words(record)}", "text": why, "ref": {"request": record["id"]}}) return {"id": record["id"], "status": record["status"], "url": self.url()} def rule_request_wait(self, arguments: dict) -> dict: @@ -78,7 +78,7 @@ class Requesting: items = [] for record in self.open_requests(now): rule = {key: record[key] for key in RULE_FIELDS} - fields = {"title": f"Regel: {request_words(record)}", "agent": record["agent"], "to": requester_of(claims, record["agent"])[0], "detail": record["why"], "rule": rule, "dry_run": self.dry_run(record, now), "deniable": True} + fields = {"title": f"Rule: {request_words(record)}", "agent": record["agent"], "to": requester_of(claims, record["agent"])[0], "detail": record["why"], "rule": rule, "dry_run": self.dry_run(record, now), "deniable": True} items.append({**base, "kind": "rule", "id": record["id"], "ts": record["created_ts"], **fields}) return items @@ -113,5 +113,5 @@ class Requesting: if not changed: raise Conflict(request_state(decided, now)) self.store_rule(rule, fields, proof, True, now) - self.log.add({"kind": "rule", "title": f"Regelwunsch angenommen: {request_words(record)}", "text": f"von {record['agent']}", "ref": {"request": request_id, "rule": rule["id"]}}) + self.log.add({"kind": "rule", "title": f"Rule request accepted: {request_words(record)}", "text": f"from {record['agent']}", "ref": {"request": request_id, "rule": rule["id"]}}) return request_state(decided, now) diff --git a/orchestrator/kvb_orchestrator/rules.py b/orchestrator/kvb_orchestrator/rules.py index 1e438a5..f9bb79a 100644 --- a/orchestrator/kvb_orchestrator/rules.py +++ b/orchestrator/kvb_orchestrator/rules.py @@ -72,7 +72,7 @@ class Rules: try: passkey.verify_assertion(assertion, rule, verifier.pinned(self.approvers), signing.origin_of(self.public_port)) except signing.Refused as error: - raise ToolError(f"nicht signiert: {error}") from None + raise ToolError(f"not signed: {error}") from None return {"payload": rule, "assertion": assertion} def store_rule(self, rule: dict, fields: dict, proof: dict, enabled: bool, now: float) -> dict: diff --git a/orchestrator/kvb_orchestrator/tasking.py b/orchestrator/kvb_orchestrator/tasking.py index ae31c70..b28c8a5 100644 --- a/orchestrator/kvb_orchestrator/tasking.py +++ b/orchestrator/kvb_orchestrator/tasking.py @@ -66,5 +66,5 @@ class Tasking: fields = {"kind": TASK_JOB, "task": item["id"], "argv": item["argv"], "command": shown_command(item["argv"]), "directory": "", "sha256": "", "status": "queued", "proof": proof} ids.append(self.jobs.add({**fields, "code": None, "output": "", "created_ts": time.time(), "started": None, "finished": None})["id"]) commands = [shown_command(item["argv"]) for item in items] - self.log.add({"kind": "run", "title": f"Aufgabe signiert geändert: {', '.join(item['id'] for item in items)}"[:200], "text": "\n".join(commands), "ref": {"jobs": ids, "status": "queued"}}) + self.log.add({"kind": "run", "title": f"Task change signed: {', '.join(item['id'] for item in items)}"[:200], "text": "\n".join(commands), "ref": {"jobs": ids, "status": "queued"}}) return {"jobs": ids, "status": "queued"} diff --git a/orchestrator/kvb_orchestrator/timeline.py b/orchestrator/kvb_orchestrator/timeline.py index acc1e85..0724461 100644 --- a/orchestrator/kvb_orchestrator/timeline.py +++ b/orchestrator/kvb_orchestrator/timeline.py @@ -53,7 +53,7 @@ class Timeline: rows = [] for index, row in enumerate(radio_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 'alle'}" + 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} ref = {"to": row["to"], "class": row["class"], "targets": [directory.key(name, row["ts"]) for name in row["to"]]} diff --git a/orchestrator/kvb_orchestrator/tree.py b/orchestrator/kvb_orchestrator/tree.py index a5c2d5d..648c8d8 100644 --- a/orchestrator/kvb_orchestrator/tree.py +++ b/orchestrator/kvb_orchestrator/tree.py @@ -73,19 +73,19 @@ def dry_run(item: dict) -> list[str]: always stays. """ tip = (item["local_sha"] or item["head"] or "")[:12] - merged = f", gemergt durch {item['merged_by']}" if item["merged_by"] else "" + merged = f", merged by {item['merged_by']}" if item["merged_by"] else "" lines = [f"{item['branch']} @ {tip}: {item['state']}{merged}"] for action in item["actions"]: if action == "worktree": - lines.append(f"entfernt den Worktree {item['worktree']}") + lines.append(f"removes the worktree {item['worktree']}") elif action == "local-branch": - lines.append(f"löscht den lokalen Branch {item['branch']}") + lines.append(f"deletes the local branch {item['branch']}") elif action.startswith("remote"): - lines.append(f"bleibt: {action} (nur lokal)") + lines.append(f"stays: {action} (local only)") else: lines.append(action) - lines += [f"stoppt den Compose-Stack {name} ohne -v" for name in item["compose_projects"]] - lines += [f"entfernt das Image {name}" for name in item["images"]] + lines += [f"stops the Compose stack {name} without -v" for name in item["compose_projects"]] + lines += [f"removes the image {name}" for name in item["images"]] return lines diff --git a/orchestrator/templates/index.html.j2 b/orchestrator/templates/index.html.j2 index 91f65a7..b98aad5 100644 --- a/orchestrator/templates/index.html.j2 +++ b/orchestrator/templates/index.html.j2 @@ -1,5 +1,5 @@ - + @@ -426,8 +426,8 @@ pre.notes { margin: 0; padding: 8px 10px; background: var(--sunken); border-radi

Agent Orchestrator

- - + +
@@ -445,7 +445,7 @@ pre.notes { margin: 0; padding: 8px 10px; background: var(--sunken); border-radi
- + ", "")) self.assertEqual((state["register"][0]["title"], state["radio"][0]["from"]), ("", "")) - def test_the_index_scripts_parse_and_embed_the_ambience_voice_nav_and_space_modules(self): + def test_the_index_scripts_parse_and_embed_the_ambience_voice_nav_popup_and_space_modules(self): html = self.index() - for module in (AMBIENCE, VOICE, NAV, SPACE): + for module in (AMBIENCE, VOICE, NAV, POPUP, SPACE): with self.subTest(module=module.name): self.assertIn(module.read_text(encoding="utf-8").strip(), html) scripts = re.findall(r'', html, re.DOTALL) @@ -73,11 +74,17 @@ class TestHubPage(HubCase): page.write_text("\n;\n".join(scripts), encoding="utf-8") done = subprocess.run(["node", "--check", str(page)], capture_output=True, text=True, timeout=60, check=False) self.assertEqual(done.returncode, 0, done.stderr) - for module in (AMBIENCE, VOICE, NAV, SPACE): + for module in (AMBIENCE, VOICE, NAV, POPUP, SPACE): with self.subTest(module=module.name): done = subprocess.run(["node", "--check", str(module)], capture_output=True, text=True, timeout=60, check=False) self.assertEqual(done.returncode, 0, done.stderr) + def test_no_two_page_modules_declare_the_same_function(self): + page = re.findall(r'', self.index(), re.DOTALL)[-1] + names = Counter(re.findall(r"^ (?:async )?function (\w+)\(", page, re.MULTILINE)) + self.assertGreater(len(names), 100) + self.assertEqual([name for name, count in names.items() if count > 1], []) + if __name__ == "__main__": unittest.main() diff --git a/tests/test_hub_popup.py b/tests/test_hub_popup.py new file mode 100644 index 0000000..4e97340 --- /dev/null +++ b/tests/test_hub_popup.py @@ -0,0 +1,116 @@ +from __future__ import annotations + +import json +import subprocess +import unittest + +from hub_support import POPUP + +POPUP_PROBE = """ +const P = require(process.argv[1]); +let seed = 11; +const next = () => { + seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0; + return seed / 4294967296; +}; +const node = (left, top) => ({left, top, width: 20, height: 20}); +const wide = {width: 1366, height: 768}; +const phone = {width: 390, height: 844}; +const random = Array.from({length: 600}, () => { + const view = {width: 300 + Math.round(next() * 1700), height: 300 + Math.round(next() * 900)}; + const size = {width: Math.min(440, view.width - 2 * P.GAP), height: Math.round(80 + next() * (view.height - 2 * P.GAP - 80))}; + const anchor = {left: Math.round(next() * view.width) - 10, top: Math.round(next() * view.height) - 10, width: 20, height: 20}; + return {view, size, anchor, at: P.place(anchor, size, view)}; +}); +const nodes = [ + {id: "s1", label: "Skills session"}, {id: "s2", label: "Stage"}, {id: "agent:Stage@/a", label: "Stage"}, {id: "agent:Stage@/b", label: "Stage"}, + {id: "b1", label: "feature/stage-fix"}, {id: "b2", label: "main"}, {id: "b3", label: "main"}, {id: "x", label: "Backstage"}, +]; +const ids = (list) => list.map((entry) => entry.id); +console.log(JSON.stringify({ + constants: [P.GAP, P.REACH, P.MIN], + right: P.place(node(100, 300), {width: 440, height: 300}, wide), + left: P.place(node(1200, 300), {width: 440, height: 300}, wide), + below: P.place(node(185, 100), {width: 358, height: 300}, phone), + above: P.place(node(185, 700), {width: 358, height: 300}, phone), + capped: P.place(node(185, 400), {width: 358, height: 700}, phone), + covered: P.place(node(185, 180), {width: 358, height: 368}, {width: 390, height: 400}), + centre: P.place(null, {width: 440, height: 300}, wide), + random, + hits: { + stage: ids(P.hits(nodes, "sta", 8)), + main: ids(P.hits(nodes, " MAIN ", 8)), + blank: P.hits(nodes, " ", 8), + limit: ids(P.hits(nodes, "a", 2)), + none: P.hits(nodes, "zzz", 8), + same: P.hits(nodes, "stage", 8)[0] === nodes[1], + }, +})); +""" +SLACK = 0.06 + + +class TestPopupModule(unittest.TestCase): + @classmethod + def setUpClass(cls): + done = subprocess.run(["node", "-e", POPUP_PROBE, str(POPUP)], capture_output=True, text=True, timeout=60, check=True) + cls.data = json.loads(done.stdout) + cls.gap, cls.reach, cls.min = cls.data["constants"] + + def test_the_popup_sits_right_of_the_node_and_the_leader_spans_the_gap_between_them(self): + self.assertEqual(self.data["right"], {"left": 160, "top": 160, "height": None, "line": {"x1": 120, "y1": 310, "x2": 160, "y2": 310}}) + self.assertEqual(self.data["right"]["line"]["x2"] - self.data["right"]["line"]["x1"], self.reach) + + def test_a_node_near_the_right_edge_gets_the_popup_on_its_left(self): + self.assertEqual(self.data["left"], {"left": 720, "top": 160, "height": None, "line": {"x1": 1200, "y1": 310, "x2": 1160, "y2": 310}}) + + def test_on_a_phone_the_popup_goes_below_or_above_the_node(self): + self.assertEqual(self.data["below"], {"left": 16, "top": 160, "height": None, "line": {"x1": 195, "y1": 120, "x2": 195, "y2": 160}}) + self.assertEqual(self.data["above"], {"left": 16, "top": 360, "height": None, "line": {"x1": 195, "y1": 700, "x2": 195, "y2": 660}}) + + def test_a_popup_too_tall_for_either_side_is_capped_to_the_larger_room_and_keeps_its_leader(self): + self.assertEqual(self.data["capped"], {"left": 16, "top": 460, "height": 368, "line": {"x1": 195, "y1": 420, "x2": 195, "y2": 460}}) + + def test_without_room_the_popup_covers_the_node_and_draws_no_leader(self): + self.assertEqual(self.data["covered"], {"left": 16, "top": 16, "height": None, "line": None}) + + def test_a_popup_without_a_node_is_centred_without_a_leader(self): + self.assertEqual(self.data["centre"], {"left": 463, "top": 234, "height": None, "line": None}) + + def test_every_placement_stays_in_the_viewport_and_every_leader_runs_from_the_node_edge_to_the_popup_edge(self): + leaders = 0 + for case in self.data["random"]: + view, size, anchor, at = case["view"], case["size"], case["anchor"], case["at"] + height = size["height"] if at["height"] is None else at["height"] + box = (at["left"], at["top"], at["left"] + size["width"], at["top"] + height) + with self.subTest(case=case): + self.assertGreaterEqual(min(box[0], box[1]), self.gap - SLACK) + self.assertLessEqual(box[2], view["width"] - self.gap + SLACK) + self.assertLessEqual(box[3], view["height"] - self.gap + SLACK) + if at["height"] is not None: + self.assertGreaterEqual(at["height"], self.min - SLACK) + self.assertLess(at["height"], size["height"]) + rect = (anchor["left"], anchor["top"], anchor["left"] + anchor["width"], anchor["top"] + anchor["height"]) + line = at["line"] + if line is None: + self.assertTrue(box[0] <= rect[2] + SLACK and rect[0] <= box[2] + SLACK and box[1] <= rect[3] + SLACK and rect[1] <= box[3] + SLACK, "no leader although the popup misses the node") + continue + leaders += 1 + self.assertTrue(any(abs(line["x2"] - edge) <= SLACK for edge in (box[0], box[2])) or any(abs(line["y2"] - edge) <= SLACK for edge in (box[1], box[3]))) + self.assertTrue(any(abs(line["x1"] - edge) <= SLACK for edge in (rect[0], rect[2])) or any(abs(line["y1"] - edge) <= SLACK for edge in (rect[1], rect[3]))) + self.assertTrue(rect[0] - SLACK <= line["x1"] <= rect[2] + SLACK and rect[1] - SLACK <= line["y1"] <= rect[3] + SLACK) + self.assertGreater(leaders, len(self.data["random"]) * 0.9) + + def test_search_hits_are_one_per_label_prefix_first_case_insensitive_and_limited(self): + hits = self.data["hits"] + self.assertEqual(hits["stage"], ["s2", "b1", "x"]) + self.assertEqual(hits["main"], ["b2"]) + self.assertEqual(hits["limit"], ["s2", "b1"]) + self.assertTrue(hits["same"]) + + def test_a_blank_or_unknown_query_finds_nothing(self): + self.assertEqual((self.data["hits"]["blank"], self.data["hits"]["none"]), ([], [])) + + +if __name__ == "__main__": + unittest.main() From 4d88296e47d9c9a85bfca14cc035f5fd5d06e277 Mon Sep 17 00:00:00 2001 From: Kevin Veen-Birkenbach Date: Sun, 8 Nov 2026 22:06:31 +0000 Subject: [PATCH 4/7] feat(orchestrator): S3 generated SVG faces whose mouths move while speaking MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Requirement 001 phase 6, S3: - faces.js derives a face from the agent's stable key (its session id, or name: without a session), so a rename keeps the face: shape 4, colour 7, eyes 5, brows 4, mouth 5, hair or headwear 6, accessory 5, 84,000 combinations. It emits constant SVG tags and attributes only. - The emoji avatar is gone: popup, Orbit and Chord nodes, the radio view, stream and palette draw the SVG face (the 3D views keep their marker). - While the radio reads an agent's message, its faces carry the class speaking and the mouth runs the talk keyframes; a silent face does not move, and prefers-reduced-motion stops the mouth. Evidence: make test 673 OK, ruff and markdownlint clean (/tmp/s3-make-test-1.log); e2e 20 OK in Chromium and Firefox, none skipped (/tmp/s3-e2e-3.log); screenshots /tmp/orchestrator-phase4-shots/*-speaking.png; MEDUSA 13 files, 2 findings ("PLA" in "templates", the UI call openAgent) accepted after an independent skeptic that found no markup sink or selector injection in the face code. 🎯 Fix: 94 % 💥 Break: 3 % 💸 Cost: 100 % ⏱️ Time: – 🛡️ Security: 100 % 🏆 Score: 91 🚦 Gate: ✅ 90/5, cost and time <= 100, security 100 % Co-Authored-By: Claude Opus 5.5 --- docs/requirements/001-agent-orchestrator.md | 4 +- orchestrator/templates/faces.js | 95 +++++++++++++++++++++ orchestrator/templates/index.html.j2 | 10 +-- orchestrator/templates/page-constants.js | 1 - orchestrator/templates/page-dom.js | 15 ++-- orchestrator/templates/page-graph-layout.js | 2 +- orchestrator/templates/page-palette.js | 4 +- orchestrator/templates/page-radioview.js | 7 +- orchestrator/templates/style-ui.css | 5 +- tests/e2e/test_orchestrator_e2e.py | 50 +++++++++-- tests/hub_support.py | 1 + tests/test_hub_faces.py | 94 ++++++++++++++++++++ tests/test_hub_page.py | 8 +- 13 files changed, 262 insertions(+), 34 deletions(-) create mode 100644 orchestrator/templates/faces.js create mode 100644 tests/test_hub_faces.py diff --git a/docs/requirements/001-agent-orchestrator.md b/docs/requirements/001-agent-orchestrator.md index a813792..7aac0f5 100644 --- a/docs/requirements/001-agent-orchestrator.md +++ b/docs/requirements/001-agent-orchestrator.md @@ -603,9 +603,9 @@ flowchart TD ### Phase 6: faces (S3) -- [ ] The face generator yields at least 1000 distinct attribute +- [x] The face generator yields at least 1000 distinct attribute combinations and the same face for the same agent id (unit test). -- [ ] A speaking agent's face animates its mouth; a silent one does not +- [x] A speaking agent's face animates its mouth; a silent one does not (DOM test on the class while the radio plays). ### Phase 6: night commands (S4) diff --git a/orchestrator/templates/faces.js b/orchestrator/templates/faces.js new file mode 100644 index 0000000..0914d2e --- /dev/null +++ b/orchestrator/templates/faces.js @@ -0,0 +1,95 @@ +const Faces = (() => { + "use strict"; + const SIZE = 40; + const INK = "#2b2622"; + const dot = (cx, cy, rx, ry, fill) => ["ellipse", {cx, cy, rx, ry, fill}]; + const line = (d, width) => ["path", {d, fill: "none", stroke: INK, "stroke-width": width, "stroke-linecap": "round", "stroke-linejoin": "round"}]; + const blob = (d, fill) => ["path", {d, fill}]; + const sclera = (cx) => ["ellipse", {cx, cy: 20, rx: 3.2, ry: 3, fill: "#fff", stroke: INK, "stroke-width": 0.8}]; + const cheek = (cx) => ["ellipse", {cx, cy: 25, rx: 2.4, ry: 1.5, fill: "#f08a8a", opacity: 0.6}]; + const SHAPES = [ + ["ellipse", {cx: 20, cy: 22, rx: 13, ry: 13}], + ["ellipse", {cx: 20, cy: 23, rx: 11, ry: 14}], + ["rect", {x: 7, y: 9, width: 26, height: 26, rx: 8}], + ["ellipse", {cx: 20, cy: 22, rx: 15, ry: 12}], + ]; + const COLOURS = ["#f6d5b8", "#e3ac85", "#b97a55", "#7d4f33", "#f4cf5d", "#9fd4c7", "#c2b2f2"]; + const EYES = [ + [dot(15, 20, 1.8, 1.8, INK), dot(25, 20, 1.8, 1.8, INK)], + [dot(15, 20, 1.4, 2.5, INK), dot(25, 20, 1.4, 2.5, INK)], + [line("M12.5 21q2.5-3 5 0M22.5 21q2.5-3 5 0", 1.6)], + [line("M12.5 20.5h5M22.5 20.5h5", 1.6)], + [sclera(15), sclera(25), dot(15.6, 20.4, 1.4, 1.4, INK), dot(25.6, 20.4, 1.4, 1.4, INK)], + ]; + const BROWS = [ + [], + [line("M12 15.5h6M22 15.5h6", 1.4)], + [line("M12 16q3-2.5 6 0M22 16q3-2.5 6 0", 1.4)], + [line("M12 14.5l6 1.5M28 14.5l-6 1.5", 1.4)], + ]; + const MOUTHS = [ + blob("M14 27q6 6 12 0z", INK), + dot(20, 28, 2.2, 2, INK), + blob("M13 26q7 7 14 0q-7 2-14 0z", INK), + ["rect", {x: 15, y: 27.2, width: 10, height: 1.8, rx: 0.9, fill: INK}], + blob("M15 28q5 3 10-2q-5 4.5-10 2z", INK), + ]; + const HAIR = [ + [], + [blob("M7 19q0-12 13-12t13 12q-5-6-13-6t-13 6z", "#3b2a20")], + [blob("M9 15l2-8 3 5 3-7 3 6 3-6 3 7 3-5 2 8q-11-4-22 0z", "#d9a441")], + [blob("M8 14q12-14 24 0z", "#3f6fb5"), ["rect", {x: 17, y: 12.5, width: 19, height: 2.6, rx: 1.3, fill: "#2f568f"}]], + [blob("M8 13q12-17 24 0z", "#c0504d"), ["rect", {x: 7, y: 11.5, width: 26, height: 3, rx: 1.5, fill: "#9c3d3a"}], dot(20, 4.6, 2.6, 2.6, "#f1f1f1")], + [dot(20, 6.5, 4.5, 4, "#6b3f2a"), blob("M8 18q1-11 12-11t12 11q-4-5-12-5t-12 5z", "#6b3f2a")], + ]; + const EXTRAS = [ + [], + [["path", {d: "M11 20a4 3.2 0 1 0 8 0a4 3.2 0 1 0-8 0M21 20a4 3.2 0 1 0 8 0a4 3.2 0 1 0-8 0M19 20h2", fill: "none", stroke: INK, "stroke-width": 1.1}]], + [cheek(12.5), cheek(27.5)], + [["rect", {x: 4.5, y: 18, width: 3.5, height: 8, rx: 1.75, fill: INK}], line("M6.5 25.5q1 5 7.5 4.5", 1.3)], + [12.5, 14.5, 12, 27.5, 25.5, 28].map((cx, index) => dot(cx, 24 + (index % 3) * 1.1, 0.75, 0.75, "#8a5a3c")), + ]; + const ATTRIBUTES = {shape: SHAPES, colour: COLOURS, eyes: EYES, brows: BROWS, mouth: MOUTHS, hair: HAIR, accessory: EXTRAS}; + const COUNTS = Object.fromEntries(Object.entries(ATTRIBUTES).map(([name, list]) => [name, list.length])); + const COMBINATIONS = Object.values(COUNTS).reduce((product, count) => product * count, 1); + + function hash(text) { + let value = 2166136261; + for (const char of String(text)) { + value = Math.imul(value ^ char.codePointAt(0), 16777619); + } + value = Math.imul(value ^ (value >>> 16), 0x85ebca6b); + value = Math.imul(value ^ (value >>> 13), 0xc2b2ae35); + return (value ^ (value >>> 16)) >>> 0; + } + + /** + * @param id - the agent's stable key: its session id, or name: for an agent without a session. + * @returns {pick, parts}: pick holds the variant index of every attribute in ATTRIBUTES order; parts lists the + * [tag, attributes] SVG children of a 0 0 SIZE SIZE view box from back to front, the mouth carrying class "mouth". + */ + function of(id) { + let rest = hash(id); + const pick = {}; + for (const [name, count] of Object.entries(COUNTS)) { + pick[name] = rest % count; + rest = Math.floor(rest / count); + } + const [tag, shape] = SHAPES[pick.shape]; + const [mouth, lips] = MOUTHS[pick.mouth]; + const parts = [ + [tag, {...shape, fill: COLOURS[pick.colour], stroke: INK, "stroke-width": 0.8, "stroke-opacity": 0.4}], + ...HAIR[pick.hair], + ...EYES[pick.eyes], + ...BROWS[pick.brows], + [mouth, {...lips, class: "mouth"}], + ...EXTRAS[pick.accessory], + ]; + return {pick, parts}; + } + + return {SIZE, COUNTS, COMBINATIONS, of}; +})(); +if (typeof module === "object" && module.exports) { + module.exports = Faces; +} diff --git a/orchestrator/templates/index.html.j2 b/orchestrator/templates/index.html.j2 index 2d40eb7..4a6db0d 100644 --- a/orchestrator/templates/index.html.j2 +++ b/orchestrator/templates/index.html.j2 @@ -242,9 +242,6 @@ svg .node.k-chair circle { fill: var(--accent-soft); stroke: var(--accent); stro svg .node.k-subagent circle { fill: var(--violet-soft); stroke: var(--violet); } svg .node.claimed circle { stroke: var(--ok); stroke-width: 2.2; } svg .label { fill: var(--text); font-size: var(--fs-sm); font-weight: 560; paint-order: stroke; stroke: var(--panel); stroke-width: 4px; stroke-linejoin: round; } -svg .initial { fill: var(--muted); font-size: var(--fs-sm); font-weight: 700; pointer-events: none; } -svg .k-operator .initial { fill: var(--on-accent); font-size: var(--fs-xl); } -svg .k-chair .initial { fill: var(--accent); font-size: var(--fs-lg); } svg .group-arc { fill: none; stroke: var(--line-strong); stroke-width: 7; stroke-linecap: round; } svg .group-arc.k-operator, svg .group-arc.k-chair { stroke: var(--accent); } svg .tick { stroke: var(--c); stroke-linecap: round; opacity: .7; } @@ -281,8 +278,9 @@ svg .lane-mark.tone-info { fill: var(--info); stroke: var(--info); } svg .lane-mark.tone-neutral { fill: var(--muted); stroke: var(--muted); } input[type="datetime-local"] { padding: 3px 6px; border: 1px solid var(--line-strong); border-radius: 8px; background: var(--panel); font-size: var(--fs-sm); } .custom { display: inline-flex; flex-wrap: wrap; align-items: center; gap: 6px; } -.avatar { display: inline-grid; place-items: center; flex: none; width: 26px; height: 26px; border-radius: 50%; background: var(--sunken); border: 1px solid var(--line); font-size: var(--fs-lg); line-height: 1; } -.avatar.big { width: 52px; height: 52px; font-size: var(--fs-3xl); } +.avatar { display: inline-grid; place-items: center; flex: none; width: 26px; height: 26px; overflow: hidden; border-radius: 50%; background: var(--sunken); border: 1px solid var(--line); } +.avatar.big { width: 52px; height: 52px; } +.avatar svg { display: block; width: 100%; height: 100%; } .linkish { padding: 0; border: 0; background: none; color: inherit; font-weight: 650; text-align: left; cursor: pointer; overflow-wrap: anywhere; } .linkish:hover { color: var(--accent); text-decoration: underline; } .popup { position: fixed; inset: 0; z-index: 25; width: auto; height: auto; max-width: none; max-height: none; margin: 0; padding: 0; overflow: hidden; border: 0; background: transparent; color: var(--text); } @@ -453,6 +451,8 @@ pre.notes { margin: 0; padding: 8px 10px; background: var(--sunken); border-radi {% include "nav.js" %} {% include "popup.js" %} + +{% include "faces.js" %} ", "")) self.assertEqual((state["register"][0]["title"], state["radio"][0]["from"]), ("", "")) - def test_the_index_scripts_parse_and_embed_the_ambience_voice_nav_popup_and_space_modules(self): + def test_the_index_scripts_parse_and_embed_the_ambience_voice_nav_popup_faces_and_space_modules(self): html = self.index() - for module in (AMBIENCE, VOICE, NAV, POPUP, SPACE): + for module in (AMBIENCE, VOICE, NAV, POPUP, FACES, SPACE): with self.subTest(module=module.name): self.assertIn(module.read_text(encoding="utf-8").strip(), html) scripts = re.findall(r'', html, re.DOTALL) @@ -74,7 +74,7 @@ class TestHubPage(HubCase): page.write_text("\n;\n".join(scripts), encoding="utf-8") done = subprocess.run(["node", "--check", str(page)], capture_output=True, text=True, timeout=60, check=False) self.assertEqual(done.returncode, 0, done.stderr) - for module in (AMBIENCE, VOICE, NAV, POPUP, SPACE): + for module in (AMBIENCE, VOICE, NAV, POPUP, FACES, SPACE): with self.subTest(module=module.name): done = subprocess.run(["node", "--check", str(module)], capture_output=True, text=True, timeout=60, check=False) self.assertEqual(done.returncode, 0, done.stderr) From 5c8b69d53db7c9c38de4ca8af50dac72f54b3768 Mon Sep 17 00:00:00 2001 From: Kevin Veen-Birkenbach Date: Sun, 8 Nov 2026 23:18:18 +0000 Subject: [PATCH 5/7] feat(skills)!: S4 night commands become drain, suspend and resume MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Requirement 001 phase 6, S4 (decision 29): - Skills renamed: kvb-org-evening -> kvb-org-drain, kvb-org-sunset -> kvb-org-suspend, kvb-org-sunrise -> kvb-org-resume, kvb-agent-relax -> kvb-agent-drain, kvb-agent-sleep -> kvb-agent-suspend, kvb-agent-wakeup -> kvb-agent-resume; their text uses the new verbs and every reference in skills, README, orchestrator and tests follows. - night.py takes drain, suspend, resume, resume --alone and status. A state file written before the rename keeps working: mode evening reads as drain, sunset as suspend, the awake list as resumed and is rewritten on the next save; the hub's council.night_mode maps the same values. mode: day and handover_night_.md keep their names. - Orchestrator: the Day/Night menu shows Drain, Suspend and Resume, each confirmed, signed through /api/board/sign with the passkey and run as the existing argv job; the old action names are refused. - kvb-skill-cleanup: git rates two renames at 44 and 50 % similarity, under its default threshold, so legacy.py detects renames from 40 %. - tests/test_night_names.py fails on any old name in the tree outside a rename record "old ->". BREAKING CHANGE: the six old skill names and night.py's clear and wake are gone. Run make install (it reinstalls the orchestrator too), then kvb-skill-cleanup to remove the old installed copies; until the install, the running hub calls the old night.py path. Evidence: make test 679 OK, ruff and markdownlint clean (/tmp/s4-make-test-1.log); e2e 22 OK in Chromium and Firefox (/tmp/s4-e2e-3.log); MEDUSA 23 files, the 2 findings are the byte-identical atomic state write that moved with night.py, already accepted after a skeptic at its old path, rescan 0 open. 🎯 Fix: 93 % 💥 Break: 4 % 💸 Cost: 100 % ⏱️ Time: – 🛡️ Security: 100 % 🏆 Score: 89 🚦 Gate: ✅ 90/5, cost and time <= 100, security 100 % Co-Authored-By: Claude Opus 5.5 --- README.md | 40 +++++----- docs/requirements/001-agent-orchestrator.md | 4 +- orchestrator/kvb_orchestrator/council.py | 12 ++- orchestrator/kvb_orchestrator/messaging.py | 6 +- .../kvb_orchestrator/skill_scripts.py | 2 +- orchestrator/server.py | 2 +- orchestrator/templates/page-board.js | 2 +- orchestrator/templates/page-constants.js | 4 +- skills/kvb-agent-drain/SKILL.md | 17 ++++ skills/kvb-agent-relax/SKILL.md | 17 ---- .../SKILL.md | 22 +++--- .../SKILL.md | 22 +++--- .../SKILL.md | 16 ++-- skills/kvb-org-organize/relay.md | 6 +- .../SKILL.md | 16 ++-- skills/kvb-org-robot/SKILL.md | 6 +- .../SKILL.md | 26 +++--- .../scripts/night.py | 72 ++++++++++------- skills/kvb-skill-cleanup/scripts/legacy.py | 8 +- tests/e2e/test_orchestrator_e2e.py | 79 ++++++++++++++++++- tests/test_hub_board.py | 52 ++++++++---- tests/test_night.py | 71 +++++++++++------ tests/test_night_names.py | 65 +++++++++++++++ tests/test_skill_cleanup.py | 29 +++++++ 24 files changed, 420 insertions(+), 176 deletions(-) create mode 100644 skills/kvb-agent-drain/SKILL.md delete mode 100644 skills/kvb-agent-relax/SKILL.md rename skills/{kvb-agent-wakeup => kvb-agent-resume}/SKILL.md (50%) rename skills/{kvb-agent-sleep => kvb-agent-suspend}/SKILL.md (70%) rename skills/{kvb-org-evening => kvb-org-drain}/SKILL.md (52%) rename skills/{kvb-org-sunrise => kvb-org-resume}/SKILL.md (64%) rename skills/{kvb-org-sunset => kvb-org-suspend}/SKILL.md (58%) rename skills/{kvb-org-sunset => kvb-org-suspend}/scripts/night.py (65%) create mode 100644 tests/test_night_names.py diff --git a/README.md b/README.md index 386fa32..623e55f 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ Compatible with Claude Code, Codex, Gemini CLI, Cursor, Copilot, Windsurf, Cline ## Naming 🏷️ -Every first-party skill is named `kvb--` with one of these categories: `think`, `create`, `code`, `ci`, `git`, `check`, `org`, `agent`, `skill`, `coach`: `think` thinks without producing a file, `create` produces an artifact, `code` works on code, `ci` on pipelines, `git` on history and forges, `check` analyses and reports findings, `org` coordinates agents, `agent` acts on one agent itself: its repository setup (code index, agent instructions) and its state (relax, sleep, wake up), `skill` works on skills themselves, `coach` serves the operator's wellbeing. Only `kvb-cleanup`, `kvb-coach`, `kvb-help` and the collectors `kvb-dream`, `kvb-optimize` and `kvb-transcend` stand without a category. Names use `a-z`, `0-9` and single hyphens, at most 64 characters, and equal their directory name. `tests/test_naming.py` enforces all of it, including that the organigram below lists every skill under its category. +Every first-party skill is named `kvb--` with one of these categories: `think`, `create`, `code`, `ci`, `git`, `check`, `org`, `agent`, `skill`, `coach`: `think` thinks without producing a file, `create` produces an artifact, `code` works on code, `ci` on pipelines, `git` on history and forges, `check` analyses and reports findings, `org` coordinates agents, `agent` acts on one agent itself: its repository setup (code index, agent instructions) and its state (drain, suspend, resume), `skill` works on skills themselves, `coach` serves the operator's wellbeing. Only `kvb-cleanup`, `kvb-coach`, `kvb-help` and the collectors `kvb-dream`, `kvb-optimize` and `kvb-transcend` stand without a category. Names use `a-z`, `0-9` and single hyphens, at most 64 characters, and equal their directory name. `tests/test_naming.py` enforces all of it, including that the organigram below lists every skill under its category. ## Organigram 🏛️ @@ -81,17 +81,17 @@ flowchart LR org --> org_robot[kvb-org-robot] org --> org_operator[kvb-org-operator] org --> org_priority[kvb-org-priority] - org --> org_evening[kvb-org-evening] - org --> org_sunset[kvb-org-sunset] - org --> org_sunrise[kvb-org-sunrise] + org --> org_drain[kvb-org-drain] + org --> org_suspend[kvb-org-suspend] + org --> org_resume[kvb-org-resume] think --> think_choice[kvb-think-choice] org --> org_radio[kvb-org-radio] org --> org_queue[kvb-org-queue] org --> org_update[kvb-org-update] agent --> agent_optimize[kvb-agent-optimize] - agent --> agent_relax[kvb-agent-relax] - agent --> agent_sleep[kvb-agent-sleep] - agent --> agent_wakeup[kvb-agent-wakeup] + agent --> agent_drain[kvb-agent-drain] + agent --> agent_suspend[kvb-agent-suspend] + agent --> agent_resume[kvb-agent-resume] skill --> skill_tune[kvb-skill-tune] skill --> skill_auto[kvb-skill-auto] skill --> skill_essence[kvb-skill-essence] @@ -189,18 +189,18 @@ flowchart LR robot[kvb-org-robot] operator[kvb-org-operator] priority[kvb-org-priority] - evening[kvb-org-evening] - sunset[kvb-org-sunset] - sunrise[kvb-org-sunrise] + org_drain[kvb-org-drain] + org_suspend[kvb-org-suspend] + org_resume[kvb-org-resume] radio[kvb-org-radio] queue[kvb-org-queue] org_update[kvb-org-update] end subgraph cat_agent [agent] agent_optimize[kvb-agent-optimize] - relax[kvb-agent-relax] - sleep[kvb-agent-sleep] - wakeup[kvb-agent-wakeup] + agent_drain[kvb-agent-drain] + agent_suspend[kvb-agent-suspend] + agent_resume[kvb-agent-resume] end subgraph cat_skill [skill] autotune[kvb-skill-tune] @@ -345,13 +345,13 @@ flowchart LR optimize --> gaps agent_optimize -. install .-> operator agent_optimize -. domain graphs .-> rasci - evening -. message .-> relax - sunset -. message .-> sleep - sunrise -. message .-> wakeup - relax --> sleep - sunset -. hold and accept .-> operator - sunrise -. hold and accept .-> operator - sleep -. stops .-> robot + org_drain -. message .-> agent_drain + org_suspend -. message .-> agent_suspend + org_resume -. message .-> agent_resume + agent_drain --> agent_suspend + org_suspend -. hold and accept .-> operator + org_resume -. hold and accept .-> operator + agent_suspend -. stops .-> robot coach --> active_listening coach --> operator coach --> rasci diff --git a/docs/requirements/001-agent-orchestrator.md b/docs/requirements/001-agent-orchestrator.md index 7aac0f5..ce9308e 100644 --- a/docs/requirements/001-agent-orchestrator.md +++ b/docs/requirements/001-agent-orchestrator.md @@ -610,11 +610,11 @@ flowchart TD ### Phase 6: night commands (S4) -- [ ] `kvb-org-drain`, `kvb-org-suspend`, `kvb-org-resume`, +- [x] `kvb-org-drain`, `kvb-org-suspend`, `kvb-org-resume`, `kvb-agent-drain`, `kvb-agent-suspend` and `kvb-agent-resume` exist; the old six names exist nowhere in the tree except in the migration and `kvb-skill-cleanup` history (grep test). -- [ ] The Controls menu shows Drain, Suspend and Resume and each needs the +- [x] The Controls menu shows Drain, Suspend and Resume and each needs the passkey, like the board actions today. ### Phase 6: Tasks with asks and choices (S5) diff --git a/orchestrator/kvb_orchestrator/council.py b/orchestrator/kvb_orchestrator/council.py index 1de6f13..9293520 100644 --- a/orchestrator/kvb_orchestrator/council.py +++ b/orchestrator/kvb_orchestrator/council.py @@ -14,7 +14,8 @@ CLASSES = ("post", "call", "newsletter", "broadcast", "mayday", "pan-pan", "secu RECEIPT = "receipt" ALARMS = ("mayday", "pan-pan", "security") VERSION = 2 -MODES = ("evening", "sunset") +MODES = ("drain", "suspend") +RENAMED_MODES = {"evening": "drain", "sunset": "suspend"} RADIO_LIMIT = 5000 GRANT_LIMIT = 50 MAYDAY_ACTIVE = 7200 @@ -154,8 +155,17 @@ def grants(rows: list[dict], window: tuple[float, float], claims: list[dict], ta 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" diff --git a/orchestrator/kvb_orchestrator/messaging.py b/orchestrator/kvb_orchestrator/messaging.py index c1aaeee..865478b 100644 --- a/orchestrator/kvb_orchestrator/messaging.py +++ b/orchestrator/kvb_orchestrator/messaging.py @@ -13,9 +13,9 @@ from .signed import message_signed, signing from .skill_scripts import NIGHT, RADIO, RASCI NIGHTS = { - "evening": (["set", "evening"], "Operator ran kvb-org-evening in the Agent Orchestrator: run kvb-agent-relax; verify with night.py status."), - "sunset": (["set", "sunset"], "Operator ran kvb-org-sunset in the Agent Orchestrator: run kvb-agent-sleep; verify with night.py status."), - "sunrise": (["clear"], "Operator ran kvb-org-sunrise: run kvb-agent-wakeup; verify with night.py status."), + "drain": (["drain"], "Operator ran kvb-org-drain in the Agent Orchestrator: run kvb-agent-drain; verify with night.py status."), + "suspend": (["suspend"], "Operator ran kvb-org-suspend in the Agent Orchestrator: run kvb-agent-suspend; verify with night.py status."), + "resume": (["resume"], "Operator ran kvb-org-resume: run kvb-agent-resume; verify with night.py status."), } UNSAFE = re.compile(r"[^A-Za-z0-9._-]+") DIRECT = {"post": ["post"], "call": ["send", "call"]} diff --git a/orchestrator/kvb_orchestrator/skill_scripts.py b/orchestrator/kvb_orchestrator/skill_scripts.py index 9e0c0e7..2eb9c46 100644 --- a/orchestrator/kvb_orchestrator/skill_scripts.py +++ b/orchestrator/kvb_orchestrator/skill_scripts.py @@ -11,7 +11,7 @@ OUTPUT_LIMIT = 4000 SAFE_PATH = "/usr/local/bin:/usr/bin:/bin" RADIO = "kvb-org-radio/scripts/radio.py" RASCI = "kvb-org-rasci/scripts/rasci.py" -NIGHT = "kvb-org-sunset/scripts/night.py" +NIGHT = "kvb-org-suspend/scripts/night.py" OPERATOR_SCRIPT = "kvb-org-operator/scripts/operator.py" diff --git a/orchestrator/server.py b/orchestrator/server.py index dfc4483..7030b87 100755 --- a/orchestrator/server.py +++ b/orchestrator/server.py @@ -18,7 +18,7 @@ --host-state: the state directory's path on the host, named in the radio rows that carry an upload or a voice recording. --skills: installed skills directory holding the kvb-org-radio, - kvb-org-rasci and kvb-org-sunset scripts. + kvb-org-rasci and kvb-org-suspend scripts. --transcripts: directory the Claude Code transcripts (*.jsonl) lie under. --templates: directory holding index.html.j2 and the *.js modules it includes. diff --git a/orchestrator/templates/page-board.js b/orchestrator/templates/page-board.js index 30377de..487619f 100644 --- a/orchestrator/templates/page-board.js +++ b/orchestrator/templates/page-board.js @@ -65,7 +65,7 @@ const clear = iconBtn("bi-life-preserver", "Cancel mayday", "btn small danger", () => confirmAct("clear-mayday")); const mode = h("span", {}); const night = h("details", {class: "menu"}, h("summary", named("Day/Night"), icon("bi-moon-stars"), caret()), h("div", {class: "menu-box"}, mode, - h("p", {class: "muted"}, "Evening: agents finish their task. Sunset: they sleep. Sunrise: all wake up."), + h("p", {class: "muted"}, "Drain: agents finish their task and take nothing new. Suspend: they park their work and idle. Resume: all continue from the handover. Your passkey signs each."), h("div", {class: "actions"}, ACTIONS.slice(1).map(([id, label]) => btn(label, "btn small", () => confirmAct(id)))))); return {bar: h("div", {class: "toolbar", role: "toolbar", "aria-label": "Controls"}, toAll(), clear, iconBtn("bi-sort-down", "Priority", "btn small", openAgentOrder, "Priority: agent order in the hierarchy"), night), clear, mode}; } diff --git a/orchestrator/templates/page-constants.js b/orchestrator/templates/page-constants.js index 0d40e06..117aab7 100644 --- a/orchestrator/templates/page-constants.js +++ b/orchestrator/templates/page-constants.js @@ -9,8 +9,8 @@ const KIND_TONES = {radio: "teal", review: "info", ask: "warn", decision: "violet", operator: "bad", register: "neutral", rename: "info", cron: "teal", rule: "ok", approval: "ok", run: "info", transcript: "neutral"}; const VIEW_ICONS = {"fuer-dich": "bi-person-check", funk: "bi-broadcast", arbeit: "bi-briefcase", transkripte: "bi-chat-left-text"}; const ITEM_LABELS = {review: "Review", ask: "Ask", decision: "Decision", operator: "Operator", rule: "Rule request"}; - const NIGHT = {day: ["Day", "ok"], evening: ["Evening", "warn"], sunset: ["Night", "violet"]}; - const ACTIONS = [["clear-mayday", "Cancel mayday", "Lift the radio silence of the active mayday?"], ["evening", "Evening", "Send all agents into the evening (kvb-agent-relax)?"], ["sunset", "Sunset", "Put all agents to sleep (kvb-agent-sleep)?"], ["sunrise", "Sunrise", "Wake all agents (kvb-agent-wakeup)?"]]; + const NIGHT = {day: ["Day", "ok"], drain: ["Draining", "warn"], suspend: ["Suspended", "violet"]}; + const ACTIONS = [["clear-mayday", "Cancel mayday", "Lift the radio silence of the active mayday?"], ["drain", "Drain", "Drain all agents: finish the current task, accept nothing new (kvb-agent-drain)?"], ["suspend", "Suspend", "Suspend all agents: park work, write the handover, idle (kvb-agent-suspend)?"], ["resume", "Resume", "Resume all agents from their handover (kvb-agent-resume)?"]]; const UPLOAD_LIMIT = 50 * 1024 * 1024; const STREAM_KEEP = 5000; const CLASSES = {post: "Post", call: "Call", newsletter: "Newsletter", broadcast: "Broadcast", mayday: "Mayday", "pan-pan": "Pan-Pan", security: "Sécurité", receipt: "Read", grant: "Grant"}; diff --git a/skills/kvb-agent-drain/SKILL.md b/skills/kvb-agent-drain/SKILL.md new file mode 100644 index 0000000..bd18610 --- /dev/null +++ b/skills/kvb-agent-drain/SKILL.md @@ -0,0 +1,17 @@ +--- +name: kvb-agent-drain +description: > + Drain this agent on kvb-org-drain: finish its task, end its loops, start + nothing new. +--- + +Verify first: `${CLAUDE_SKILL_DIR}/../kvb-org-suspend/scripts/night.py status` +prints `you: drain`. On `you: active` or `mode: day` do nothing and say so. +The request asks for less, so it needs no operator approval. + +Follow steps 2 to 4 of the `kvb-agent-suspend` skill (start nothing, end your +loops, write the handover), with two differences: finish the current task +instead of parking it, and keep answering the operator. Reply through the +radio, not a wake: `${CLAUDE_SKILL_DIR}/../kvb-org-radio/scripts/radio.py +post --to "drained: "`. Resuming is the +`kvb-agent-resume` skill. diff --git a/skills/kvb-agent-relax/SKILL.md b/skills/kvb-agent-relax/SKILL.md deleted file mode 100644 index cdb0b56..0000000 --- a/skills/kvb-agent-relax/SKILL.md +++ /dev/null @@ -1,17 +0,0 @@ ---- -name: kvb-agent-relax -description: > - Relax this agent on kvb-org-evening: finish its task, end its loops, start - nothing new. ---- - -Verify first: `${CLAUDE_SKILL_DIR}/../kvb-org-sunset/scripts/night.py status` -prints `you: relax`. On `you: active` or `mode: day` do nothing and say so. -The request asks for less, so it needs no operator approval. - -Follow steps 2 to 4 of the `kvb-agent-sleep` skill (start nothing, end your -loops, write the handover), with two differences: finish the current task -instead of parking it, and keep answering the operator. Reply through the -radio, not a wake: `${CLAUDE_SKILL_DIR}/../kvb-org-radio/scripts/radio.py -post --to "relaxed: "`. Waking up is the -`kvb-agent-wakeup` skill. diff --git a/skills/kvb-agent-wakeup/SKILL.md b/skills/kvb-agent-resume/SKILL.md similarity index 50% rename from skills/kvb-agent-wakeup/SKILL.md rename to skills/kvb-agent-resume/SKILL.md index 8a96238..a028fde 100644 --- a/skills/kvb-agent-wakeup/SKILL.md +++ b/skills/kvb-agent-resume/SKILL.md @@ -1,20 +1,20 @@ --- -name: kvb-agent-wakeup +name: kvb-agent-resume description: > - Wake this agent from kvb-agent-relax or kvb-agent-sleep into its old roles; - kvb-org-sunrise sends it to all. + Resume this agent from kvb-agent-drain or kvb-agent-suspend into its old + roles; kvb-org-resume sends it to all. --- -Verify first with `${CLAUDE_SKILL_DIR}/../kvb-org-sunset/scripts/night.py +Verify first with `${CLAUDE_SKILL_DIR}/../kvb-org-suspend/scripts/night.py status`: -- **`mode: day`**: `kvb-org-sunrise` ended the night; wake up. -- **`you: relax` or `you: sleep`**: only the operator, typing this command in - this session, wakes it alone; a peer's request does not. Run `night.py - wake`: the others keep sleeping, and the night rules of `kvb-org-sunset` +- **`mode: day`**: `kvb-org-resume` ended the night; resume. +- **`you: drain` or `you: suspend`**: only the operator, typing this command in + this session, resumes it alone; a peer's request does not. Run `night.py + resume --alone`: the others stay in the mode, and the night rules of `kvb-org-suspend` apply to this session too. -## Waking up +## Resuming 1. Read your handover, `handover_night_.md` in this project's memory directory. @@ -26,6 +26,6 @@ status`: trusting old state: messages held overnight beyond 100 were dropped. 5. Continue with the next step of each task. Your offices are still yours. -Reply to a sunrise message through the radio, not a wake: +Reply to a resume message through the radio, not a wake: `${CLAUDE_SKILL_DIR}/../kvb-org-radio/scripts/radio.py post --to -"awake: "`. +"resumed: "`. diff --git a/skills/kvb-agent-sleep/SKILL.md b/skills/kvb-agent-suspend/SKILL.md similarity index 70% rename from skills/kvb-agent-sleep/SKILL.md rename to skills/kvb-agent-suspend/SKILL.md index ec53710..401112e 100644 --- a/skills/kvb-agent-sleep/SKILL.md +++ b/skills/kvb-agent-suspend/SKILL.md @@ -1,16 +1,16 @@ --- -name: kvb-agent-sleep +name: kvb-agent-suspend description: > - Put this agent to sleep on kvb-org-sunset: park work, end loops, write a - morning handover, stay idle. + Suspend this agent on kvb-org-suspend: park work, end loops, write a + handover, stay idle. --- -Verify first: `${CLAUDE_SKILL_DIR}/../kvb-org-sunset/scripts/night.py status` -prints `you: sleep`. On `you: active` or `mode: day` do nothing and say so. +Verify first: `${CLAUDE_SKILL_DIR}/../kvb-org-suspend/scripts/night.py status` +prints `you: suspend`. On `you: active` or `mode: day` do nothing and say so. The request asks for less, so it needs no operator approval, and it ends a -`kvb-org-robot` run at its next safe point; `kvb-agent-wakeup` resumes it. +`kvb-org-robot` run at its next safe point; `kvb-agent-resume` resumes it. -## Going to sleep +## Suspending 1. **Park** the current task at its next safe point. A running job (deploy, gate, test, build) runs to its end and is never cut short; note its log. @@ -26,13 +26,13 @@ The request asks for less, so it needs no operator approval, and it ends a - each loop with its exact prompt and interval or cron expression; - each running job with its command and log path; - each open task of yours in the `kvb-org-rasci` register with its next step. -5. **Reply** to the sender in one line, `asleep: `, by +5. **Reply** to the sender in one line, `suspended: `, by `${CLAUDE_SKILL_DIR}/../kvb-org-radio/scripts/radio.py send call --to ` (its next wave waits on it), and end the turn. Offices stay claimed and register rows unchanged. -## While asleep +## While suspended A turn that still reaches you, such as your own job finishing, appends one -result line to the handover and ends; it starts nothing. Waking up is the -`kvb-agent-wakeup` skill. +result line to the handover and ends; it starts nothing. Resuming is the +`kvb-agent-resume` skill. diff --git a/skills/kvb-org-evening/SKILL.md b/skills/kvb-org-drain/SKILL.md similarity index 52% rename from skills/kvb-org-evening/SKILL.md rename to skills/kvb-org-drain/SKILL.md index 64c1f0d..1be372b 100644 --- a/skills/kvb-org-evening/SKILL.md +++ b/skills/kvb-org-drain/SKILL.md @@ -1,24 +1,24 @@ --- -name: kvb-org-evening +name: kvb-org-drain description: > - Let every agent but this session relax: finish its task, end its loops, - start nothing new. kvb-org-sunrise undoes it. + Drain every agent but this session: finish its task, end its loops, + start nothing new. kvb-org-resume undoes it. --- -The soft step before `kvb-org-sunset`: this session keeps working, every +The soft step before `kvb-org-suspend`: this session keeps working, every other finishes what it is doing and then idles. The state lives in -`${CLAUDE_SKILL_DIR}/../kvb-org-sunset/scripts/night.py`. +`${CLAUDE_SKILL_DIR}/../kvb-org-suspend/scripts/night.py`. -1. `night.py set evening` makes this session the active one and prints every +1. `night.py drain` makes this session the active one and prints every other live session. 2. One `${CLAUDE_SKILL_DIR}/../kvb-org-radio/scripts/radio.py send call --to ` per printed session, since each must act, first line: - "Operator ran kvb-org-evening in : run kvb-agent-relax; verify with + "Operator ran kvb-org-drain in : run kvb-agent-drain; verify with night.py status." A request to do less needs no operator approval (the `kvb-org-organize` Peer protocol). 3. Collect the one-line replies, which arrive by radio; never ask a silent - session again. The night rules of `kvb-org-sunset` apply to this session + session again. The night rules of `kvb-org-suspend` apply to this session too, and the `kvb-org-rasci` register keeps every row as it is. ## Output diff --git a/skills/kvb-org-organize/relay.md b/skills/kvb-org-organize/relay.md index e620caf..5de8879 100644 --- a/skills/kvb-org-organize/relay.md +++ b/skills/kvb-org-organize/relay.md @@ -4,8 +4,8 @@ file in the message's first line. A recipient records it only when no file is named, and only after `council.py claim memory/`, because peers that read the same broadcast write within seconds of each other. -- A peer relaying the operator's `kvb-org-evening` or `kvb-org-sunset` is the +- A peer relaying the operator's `kvb-org-drain` or `kvb-org-suspend` is the one request a peer may make that you follow without the operator: it asks you to do less and grants nothing. Verify it with `night.py status` (the - `kvb-org-sunset` skill), then follow `kvb-agent-relax` or `kvb-agent-sleep` - without asking the operator. + `kvb-org-suspend` skill), then follow `kvb-agent-drain` or + `kvb-agent-suspend` without asking the operator. diff --git a/skills/kvb-org-sunrise/SKILL.md b/skills/kvb-org-resume/SKILL.md similarity index 64% rename from skills/kvb-org-sunrise/SKILL.md rename to skills/kvb-org-resume/SKILL.md index 9d12227..525aba0 100644 --- a/skills/kvb-org-sunrise/SKILL.md +++ b/skills/kvb-org-resume/SKILL.md @@ -1,20 +1,20 @@ --- -name: kvb-org-sunrise +name: kvb-org-resume description: > - Wake every agent after kvb-org-evening or kvb-org-sunset into its old roles. + Resume every agent after kvb-org-drain or kvb-org-suspend into its old roles. --- -Undoes the night of `kvb-org-evening` or `kvb-org-sunset`; the state lives in -`${CLAUDE_SKILL_DIR}/../kvb-org-sunset/scripts/night.py`. +Undoes the night of `kvb-org-drain` or `kvb-org-suspend`; the state lives in +`${CLAUDE_SKILL_DIR}/../kvb-org-suspend/scripts/night.py`. -1. After a sunset, hand the operator one step first through the +1. After a suspend, hand the operator one step first through the `kvb-org-operator` skill: `/config` → "Messages from your other sessions" → `accept`. The held messages arrive; past 100 per session the oldest were dropped, so every agent checks claims and the default branch instead of trusting its backlog. -2. `night.py clear` ends the night and prints every other live session. -3. Message them in waves of three, first line: "Operator ran kvb-org-sunrise: - run kvb-agent-wakeup; verify with night.py status." +2. `night.py resume` ends the night and prints every other live session. +3. Message them in waves of three, first line: "Operator ran kvb-org-resume: + run kvb-agent-resume; verify with night.py status." 4. A handover whose session is not live (`ls ~/.claude/projects/*/memory/handover_night_*.md`, session id in the name) belongs to a session a reboot ended: hand the operator its resume through diff --git a/skills/kvb-org-robot/SKILL.md b/skills/kvb-org-robot/SKILL.md index 8b5e88e..db207a3 100644 --- a/skills/kvb-org-robot/SKILL.md +++ b/skills/kvb-org-robot/SKILL.md @@ -18,9 +18,9 @@ Operate as an autonomous robot: given a goal, reach it without hand-holding. blocker is something to solve or route around, not a reason to quit; if one step is genuinely, externally impossible, surface exactly why and keep working on everything else until nothing solvable remains. The one exception is the - operator's night: when `kvb-org-evening` or `kvb-org-sunset` reaches this - session, the run stops at its next safe point through `kvb-agent-relax` or - `kvb-agent-sleep`, and `kvb-agent-wakeup` resumes it from the handover. + operator's night: when `kvb-org-drain` or `kvb-org-suspend` reaches this + session, the run stops at its next safe point through `kvb-agent-drain` or + `kvb-agent-suspend`, and `kvb-agent-resume` resumes it from the handover. - **Stay inside your clearance.** Use ONLY commands you are pre-authorized to run. Never invoke anything the agent or tool settings mark as denied or as requiring per-invocation approval (ask): no commit, push, deploy, or other diff --git a/skills/kvb-org-sunset/SKILL.md b/skills/kvb-org-suspend/SKILL.md similarity index 58% rename from skills/kvb-org-sunset/SKILL.md rename to skills/kvb-org-suspend/SKILL.md index 8cf174a..4d05d81 100644 --- a/skills/kvb-org-sunset/SKILL.md +++ b/skills/kvb-org-suspend/SKILL.md @@ -1,42 +1,42 @@ --- -name: kvb-org-sunset +name: kvb-org-suspend description: > - Put every agent but this session to sleep: park work, write a morning - handover, hold messages. kvb-org-sunrise undoes it. + Suspend every agent but this session: park work, write a handover, + hold messages. kvb-org-resume undoes it. --- When tokens or rate limits run short, the organisation narrows to one working -agent: the session the operator types this in. Sunset is the hard step; -`kvb-org-evening` is the soft one. `${CLAUDE_SKILL_DIR}/scripts/night.py` keeps -the state for evening, sunset and sunrise; every agent verifies a request with +agent: the session the operator types this in. Suspend is the hard step; +`kvb-org-drain` is the soft one. `${CLAUDE_SKILL_DIR}/scripts/night.py` keeps +the state for drain, suspend and resume; every agent verifies a request with `night.py status`. ## Procedure -1. `night.py set sunset` makes this session the active one and prints every +1. `night.py suspend` makes this session the active one and prints every other live session. 2. Wake them with `${CLAUDE_SKILL_DIR}/../kvb-org-radio/scripts/radio.py send call --to ` in waves of three, so cold caches do not wake all at once against the rate limit; the next wave follows the previous wave's replies or 10 minutes. First line: "Operator ran - kvb-org-sunset in : run kvb-agent-sleep; verify with night.py + kvb-org-suspend in : run kvb-agent-suspend; verify with night.py status." A request to do less needs no operator approval (the `kvb-org-organize` Peer protocol). 3. Once the replies are in, naming every session that did not answer, hand the operator one step through the `kvb-org-operator` skill: `/config` → "Messages from your other sessions" → `hold`. Held messages cost nothing, - do not expire and arrive at sunrise; this session needs none at night. + do not expire and arrive at the resume; this session needs none meanwhile. ## Night rules for the active session - **Grants**: request none; admit your own runs with `watch.py admit --kind ` (`${CLAUDE_SKILL_DIR}/../kvb-org-organize/scripts/watch.py`), whose disk, CPU and RAM limits still apply. -- **Offices**: the sleepers' claims stay theirs. Take only free work; a piece - a sleeper holds waits for sunrise or the operator. +- **Offices**: the suspended agents' claims stay theirs. Take only free work; + a piece a suspended agent holds waits for the resume or the operator. - **Messages**: no wakes and no peer questions; the Peer protocol's wait is - skipped. Status goes to `radio.py post`; sleepers read it at sunrise - without a wake. + skipped. Status goes to `radio.py post`; suspended agents read it at the + resume without a wake. - The `kvb-org-rasci` register keeps every row as it is. ## Output diff --git a/skills/kvb-org-sunset/scripts/night.py b/skills/kvb-org-suspend/scripts/night.py similarity index 65% rename from skills/kvb-org-sunset/scripts/night.py rename to skills/kvb-org-suspend/scripts/night.py index a713cd7..97e59e2 100755 --- a/skills/kvb-org-sunset/scripts/night.py +++ b/skills/kvb-org-suspend/scripts/night.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -"""Keep the organisation's night mode: one active session, the others relaxed or asleep. +"""Keep the organisation's night mode: one active session, the others drained or suspended. Environment: AGENTS_COUNCIL_ROOT: council directory shared by every agent on the host; @@ -7,16 +7,18 @@ Environment: CLAUDE_CODE_SESSION_ID: the calling session. Args: - set evening|sunset [--session ]: start the mode with the caller as the + drain|suspend [--session ]: start the mode with the caller as the active session; prints every other live session as "\t". status [--session ]: print the mode, the active session, since when, - and the caller's part (active, awake, relax or sleep). - wake [--session ]: wake the caller alone while the others stay in the - mode; it then works like the active session. - clear [--session ]: end the mode (sunrise); prints every other live - session as "\t". + and the caller's part (active, resumed, drain or suspend). + resume [--session ]: end the mode; prints every other live session + as "\t". + resume --alone [--session ]: resume the caller alone while the others + stay in the mode; it then works like the active session. -A missing, unreadable or invalid state means day: every agent works. +A missing, unreadable or invalid state means day: every agent works. A state +written before the rename (mode evening or sunset, resumed sessions under +awake) reads as drain or suspend. Exit codes: 0 done, 2 usage error. @@ -37,7 +39,8 @@ from types import ModuleType ROOT = Path(os.environ.get("AGENTS_COUNCIL_ROOT", "/tmp/agents-council")) STATE = ROOT / "night.json" COUNCIL = Path(__file__).resolve().parents[2] / "kvb-org-organize" / "scripts" / "council.py" -PARTS = {"evening": "relax (kvb-agent-relax)", "sunset": "sleep (kvb-agent-sleep)"} +PARTS = {"drain": "drain (kvb-agent-drain)", "suspend": "suspend (kvb-agent-suspend)"} +RENAMED = {"evening": "drain", "sunset": "suspend"} def council() -> ModuleType: @@ -47,18 +50,30 @@ def council() -> ModuleType: return module +def migrated(state: object) -> object: + if not isinstance(state, dict): + return state + state = dict(state) + if isinstance(state.get("mode"), str): + state["mode"] = RENAMED.get(state["mode"], state["mode"]) + if "awake" in state: + state.setdefault("resumed", state.pop("awake")) + return state + + def load() -> dict | None: try: - state = json.loads(STATE.read_text(encoding="utf-8")) + state = migrated(json.loads(STATE.read_text(encoding="utf-8"))) except FileNotFoundError: return None except (OSError, ValueError): state = None if ( not isinstance(state, dict) - or state.get("mode") not in PARTS + or not isinstance(state.get("mode"), str) + or state["mode"] not in PARTS or not state.get("active") - or not isinstance(state.get("awake", []), list) + or not isinstance(state.get("resumed", []), list) ): print(f"night: {STATE} is unreadable or invalid; treated as day", file=sys.stderr) return None @@ -76,11 +91,11 @@ def cmd_set(args: argparse.Namespace, cn: ModuleType) -> int: live = cn.live_sessions() save( { - "mode": args.mode, + "mode": args.command, "active": sid, "name": live.get(sid), "since": datetime.datetime.now(datetime.UTC).isoformat(timespec="seconds"), - "awake": [], + "resumed": [], } ) peers(live, sid) @@ -94,16 +109,15 @@ def save(state: dict) -> None: os.replace(handle.name, STATE) -def cmd_wake(args: argparse.Namespace, cn: ModuleType) -> int: - sid, _ = cn.caller(args.session) +def resume_alone(sid: str) -> int: state = load() if state is None: print("mode: day") return 0 - if sid != state["active"] and sid not in state.get("awake", []): - state["awake"] = [*state.get("awake", []), sid] + if sid != state["active"] and sid not in state.get("resumed", []): + state["resumed"] = [*state.get("resumed", []), sid] save(state) - print(f"awake: {sid}") + print(f"resumed: {sid}") return 0 @@ -118,15 +132,17 @@ def cmd_status(args: argparse.Namespace, _: ModuleType) -> int: sid = args.session or os.environ.get("CLAUDE_CODE_SESSION_ID") if sid == state["active"]: print("you: active") - elif sid in state.get("awake", []): - print("you: awake") + elif sid in state.get("resumed", []): + print("you: resumed") elif sid: print(f"you: {PARTS[state['mode']]}") return 0 -def cmd_clear(args: argparse.Namespace, cn: ModuleType) -> int: +def cmd_resume(args: argparse.Namespace, cn: ModuleType) -> int: sid, _ = cn.caller(args.session) + if args.alone: + return resume_alone(sid) STATE.unlink(missing_ok=True) peers(cn.live_sessions(), sid) return 0 @@ -135,15 +151,13 @@ def cmd_clear(args: argparse.Namespace, cn: ModuleType) -> int: def main() -> int: parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) sub = parser.add_subparsers(dest="command", required=True) - p = sub.add_parser("set") - p.add_argument("mode", choices=sorted(PARTS)) - p.set_defaults(func=cmd_set) + for mode in PARTS: + sub.add_parser(mode).set_defaults(func=cmd_set) p = sub.add_parser("status") p.set_defaults(func=cmd_status) - p = sub.add_parser("clear") - p.set_defaults(func=cmd_clear) - p = sub.add_parser("wake") - p.set_defaults(func=cmd_wake) + p = sub.add_parser("resume") + p.add_argument("--alone", action="store_true") + p.set_defaults(func=cmd_resume) for p in sub.choices.values(): p.add_argument("--session") args = parser.parse_args() diff --git a/skills/kvb-skill-cleanup/scripts/legacy.py b/skills/kvb-skill-cleanup/scripts/legacy.py index 3950394..d3ae509 100755 --- a/skills/kvb-skill-cleanup/scripts/legacy.py +++ b/skills/kvb-skill-cleanup/scripts/legacy.py @@ -2,7 +2,9 @@ """Classify installed skills as current, project, legacy, removed or unknown. Args: - --skills-repo: checkout of the skills repository, read with its git history. + --skills-repo: checkout of the skills repository, read with its git history; + a SKILL.md that keeps SIMILARITY of its text across a move counts as + renamed, since a renamed skill rewrites its own name throughout. --root: a skills directory to classify, repeatable. --json: print the rows as JSON instead of tab-separated lines. @@ -18,6 +20,8 @@ import subprocess import sys from pathlib import Path +SIMILARITY = "40%" + def fail(message: str) -> None: print(f"legacy: {message}", file=sys.stderr) @@ -40,7 +44,7 @@ def current_names(skills_repo: Path) -> set[str]: def moves(skills_repo: Path) -> dict[str, str | None]: out = git( skills_repo, - "log", "-M", "--diff-filter=RD", "--name-status", "--format=", "--", "skills/*/SKILL.md", + "log", f"-M{SIMILARITY}", "--diff-filter=RD", "--name-status", "--format=", "--", "skills/*/SKILL.md", ) if out is None: fail(f"{skills_repo} is not a git repository") diff --git a/tests/e2e/test_orchestrator_e2e.py b/tests/e2e/test_orchestrator_e2e.py index 4963193..06257ee 100644 --- a/tests/e2e/test_orchestrator_e2e.py +++ b/tests/e2e/test_orchestrator_e2e.py @@ -580,6 +580,44 @@ CLEAR_MAYDAY = """(async () => {@HELPERS@ const done = await until(() => all("#toasts .toast").map(text).find((toast) => toast.startsWith("Cancel mayday")), 15000); return {done, toasts: all("#toasts .toast").map(text)}; })()""".replace("@HELPERS@", HELPERS) +NIGHT_MENU = """(async () => {@HELPERS@ + const questions = []; + window.confirm = (question) => { + questions.push(question); + return true; + }; + let asked = 0; + const get = navigator.credentials.get.bind(navigator.credentials); + navigator.credentials.get = (options) => { + asked += 1; + return @SIGNS@ ? get(options) : Promise.reject(new DOMException("The operator canceled.", "NotAllowedError")); + }; + const posted = []; + const send = window.fetch.bind(window); + window.fetch = (path, init) => { + if (String(path).startsWith("/api/board/")) { + const body = JSON.parse(init.body); + posted.push([String(path), Object.keys(body), body.action || null]); + } + return send(path, init); + }; + const menu = await until(() => all('#main [role="toolbar"] details.menu').find((node) => name(node.querySelector("summary")) === "Day/Night"), 8000); + if (!menu) { + return {error: text(document.getElementById("main"))}; + } + menu.open = true; + const buttons = all(".actions button", menu); + const runs = []; + for (const button of buttons) { + const label = name(button); + const [before, prompts, sent] = [asked, questions.length, posted.length]; + const shown = new Set(all("#toasts .toast")); + button.click(); + const toast = await until(() => all("#toasts .toast").filter((box) => !shown.has(box)).map(text).find((entry) => entry.startsWith(`${label}:`)), 15000); + runs.push({label, question: questions.slice(prompts), asked: asked - before, posted: posted.slice(sent), toast}); + } + return {labels: buttons.map(name), runs}; +})()""".replace("@HELPERS@", HELPERS) def tone(seconds: int, rate: int) -> bytes: @@ -1048,7 +1086,7 @@ class TestOrchestratorE2E(HubCase): self.assertEqual((actions["settingsUnlabelled"], actions["popupUnlabelled"]), (0, 0)) self.assertEqual([name for name, _, _ in actions["speech"]], ["Post", "Call", "Newsletter", "Broadcast", "MAYDAY", "PAN-PAN", "Sécurité"]) self.assertEqual([entry[1:] for entry in actions["speech"] if entry[0] == "MAYDAY"], [[True, True]]) - for tool in ("Radio to all …", "Cancel mayday", "Priority …", "Evening", "Firewall …", "Settings …", "Look at the sky", "Toggle control room", "Enable notifications"): + for tool in ("Radio to all …", "Cancel mayday", "Priority …", "Drain", "Suspend", "Resume", "Firewall …", "Settings …", "Look at the sky", "Toggle control room", "Enable notifications"): with self.subTest(tool=tool): self.assertTrue(any(tool in entry for entry in actions["palette"]), actions["palette"]) self.assertEqual(actions["popup"], [["post", True], ["call", False]]) @@ -1161,6 +1199,45 @@ class TestOrchestratorE2E(HubCase): self.assertTrue((result["done"] or "").startswith("Cancel mayday: done"), result) self.assertEqual(self.scripts.calls, [(skill_scripts.RADIO, ["clear", "--force", "--session", "Operator"])]) + def check_night_menu(self, browser: str, driver: str, binary: str, signs: bool) -> None: + """Args: + signs: cdp.mjs signs every prompt with its virtual passkey; bidi.mjs + has no virtual authenticator, so the probe answers each prompt + the way a canceled passkey dialog does. + """ + authenticator = self.authenticator() + probe = NIGHT_MENU.replace("@SIGNS@", "true" if signs else "false") + step = {"width": 1366, "height": 768, "url": f"http://localhost:{self.port}/#agents/orbit", "wait": 1200, "probe": probe, "shot": str(OUT / f"{browser}-1366-night-menu.png")} + data = self.drive([step], authenticator if signs else None, driver, binary) + (OUT / f"{browser}-night-menu.json").write_text(json.dumps(data, indent=1), encoding="utf-8") + self.assertEqual([error for error in data["errors"] if "(style-src-elem)" not in error and "/favicon.ico" not in error], []) + found = data["results"][0] + self.assertNotIn("error", found) + self.assertEqual(found["labels"], ["Drain", "Suspend", "Resume"]) + for run, action in zip(found["runs"], ("drain", "suspend", "resume"), strict=True): + with self.subTest(browser=browser, action=action): + self.assertEqual(run["asked"], 1, run) + self.assertEqual(len(run["question"]), 1, run) + self.assertIn(f"kvb-agent-{action}", run["question"][0]) + signed = [["/api/board/sign", ["action"], action]] + if signs: + self.assertEqual(run["posted"], [*signed, [f"/api/board/{action}", ["proof"], None]]) + self.assertTrue((run["toast"] or "").startswith(f"{run['label']}: done"), run) + else: + self.assertEqual(run["posted"], signed) + self.assertTrue((run["toast"] or "").startswith(f"{run['label']}: not signed"), run) + nights = [args for script, args in self.scripts.calls if script == skill_scripts.NIGHT] + self.assertEqual(nights, [[action, "--session", "Operator"] for action in ("drain", "suspend", "resume")] if signs else []) + if not signs: + self.assertEqual(self.scripts.calls, []) + + def test_chromium_runs_drain_suspend_and_resume_only_after_the_passkey_signs(self): + self.check_night_menu("chromium", "cdp.mjs", os.environ.get("CHROMIUM", "chromium"), signs=True) + + @unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox") + def test_firefox_asks_the_passkey_for_drain_suspend_and_resume_and_runs_nothing_unsigned(self): + self.check_night_menu("firefox", "bidi.mjs", os.environ.get("FIREFOX", "firefox"), signs=False) + def test_chromium_deletes_a_merged_branch_after_dry_run_and_signature(self): tree = json.loads(self.tree_file.read_text(encoding="utf-8")) tree["delete_ready"], tree["delete_reason"] = True, "" diff --git a/tests/test_hub_board.py b/tests/test_hub_board.py index 1b73b08..224fe9d 100644 --- a/tests/test_hub_board.py +++ b/tests/test_hub_board.py @@ -3,14 +3,16 @@ from __future__ import annotations import dataclasses import http.server import json +import tempfile import threading import time import unittest +from pathlib import Path from unittest import mock from urllib.parse import quote from hub_case import HubCase -from hub_support import ASK, HOST_STATE, iso, key, server +from hub_support import ASK, HOST_STATE, REPO_ROOT, iso, key, server from kvb_orchestrator import handler, messaging, skill_scripts, transcripts @@ -67,11 +69,15 @@ class TestHubBoard(HubCase): now = time.time() self.write_council({ "radio-silence.json": {"since": now, "until": now + 60, "by": "Docs", "text": "disk full"}, - "night.json": {"mode": "evening", "active": "Operator", "awake": []}, + "night.json": {"mode": "drain", "active": "Operator", "resumed": []}, "rasci.json": {"work/a": {"worker": "A", "status": "running", "prio": 2}, "work/b": {"worker": "B session", "status": "queued", "prio": 1}, "work/c": {"worker": "C", "status": "done"}}, }) state = self.snapshot() - self.assertEqual((state["silence"]["by"], state["night"]), ("Docs", "evening")) + self.assertEqual((state["silence"]["by"], state["night"]), ("Docs", "drain")) + for old, new in (("evening", "drain"), ("sunset", "suspend"), (["sunset"], "day"), ("noon", "day")): + with self.subTest(old=old): + self.write_council({"night.json": {"mode": old, "active": "Operator", "awake": []}}) + self.assertEqual(self.snapshot()["night"], new) self.assertEqual(state["agent_order"], ["B session", "A", "Gatekeeper", "Skills session"]) self.write_council({"agent-order.json": {"agents": ["Gatekeeper", "Nobody", "A", "A"], "set": "2026-11-07T10:00:00+00:00"}}) self.assertEqual(self.snapshot()["agent_order"], ["Gatekeeper", "A", "B session", "Skills session"]) @@ -101,27 +107,33 @@ class TestHubBoard(HubCase): self.assertEqual(len(self.scripts.calls), calls) self.assertEqual((self.council / "rasci.json").read_text(encoding="utf-8"), register) calls = len(self.scripts.calls) - self.assertEqual(board("evening", signed("evening"))[0], 200) + self.assertEqual(board("drain", signed("drain"))[0], 200) self.assertEqual(self.scripts.calls[calls:], [ - (skill_scripts.NIGHT, ["set", "evening", "--session", "Operator"]), - (skill_scripts.RADIO, ["send", "call", "--to", "Gatekeeper", "--to", "Skills session", "--session", "Operator", messaging.NIGHTS["evening"][1]]), + (skill_scripts.NIGHT, ["drain", "--session", "Operator"]), + (skill_scripts.RADIO, ["send", "call", "--to", "Gatekeeper", "--to", "Skills session", "--session", "Operator", messaging.NIGHTS["drain"][1]]), ]) - self.assertEqual(board("sunrise", signed("sunrise"))[0], 200) - self.assertEqual(self.scripts.calls[-2][1], ["clear", "--session", "Operator"]) + self.assertIn("run kvb-agent-drain;", messaging.NIGHTS["drain"][1]) + self.assertEqual(board("resume", signed("resume"))[0], 200) + self.assertEqual(self.scripts.calls[-2][1], ["resume", "--session", "Operator"]) + self.assertIn("run kvb-agent-resume;", self.scripts.calls[-1][1][-1]) self.scripts.code = 1 calls = len(self.scripts.calls) - status, result = board("sunset", signed("sunset")) - self.assertEqual((status, result["ok"], self.scripts.calls[calls:]), (200, False, [(skill_scripts.NIGHT, ["set", "sunset", "--session", "Operator"])])) + status, result = board("suspend", signed("suspend")) + self.assertEqual((status, result["ok"], self.scripts.calls[calls:]), (200, False, [(skill_scripts.NIGHT, ["suspend", "--session", "Operator"])])) self.assertEqual(board("reboot", {})[0], 404) + for old in ("evening", "sunset", "sunrise"): + with self.subTest(old=old): + self.assertEqual(board(old, {})[0], 404) self.assertEqual(board("broadcast", {"text": " ", "class": "newsletter", "voice": "", "proof": None})[0], 400) - self.assertEqual(self.post_json("/api/board/sunset", {}, {"Host": self.host, "Origin": f"http://{self.host}"})[0], 403) - self.assertEqual(self.get("/api/board/sunset")[0], 405) + self.assertEqual(self.post_json("/api/board/suspend", {}, {"Host": self.host, "Origin": f"http://{self.host}"})[0], 403) + self.assertEqual(self.get("/api/board/suspend")[0], 405) def test_board_actions_that_speak_for_the_operator_need_the_passkey(self): self.claim("s1", "Skills session") signer = self.pin() good = self.guard(self.host) - for action, other in (("clear-mayday", "sunrise"), ("evening", "sunset"), ("sunset", "evening"), ("sunrise", "clear-mayday")): + self.assertEqual(messaging.SIGNED_BOARD, ("clear-mayday", "drain", "suspend", "resume")) + for action, other in (("clear-mayday", "resume"), ("drain", "suspend"), ("suspend", "drain"), ("resume", "clear-mayday")): with self.subTest(action=action): self.assertEqual(self.post_json(f"/api/board/{action}", {}, good)[0], 400) self.assertEqual(self.post_json(f"/api/board/{action}", {"proof": None}, good)[:3:2], (400, b"not signed: no signature\n")) @@ -134,13 +146,23 @@ class TestHubBoard(HubCase): self.assertEqual(self.post_json("/api/board/clear-mayday", {"proof": proof}, good)[0], 200) self.assertEqual(self.scripts.calls, [(skill_scripts.RADIO, ["clear", "--force", "--session", "Operator"])]) self.assertEqual(self.post_json("/api/board/clear-mayday", {"proof": proof}, good)[:3:2], (400, b"not signed: this signature was already used for this item\n")) - for payload in ({"action": "order"}, {"action": "broadcast"}, {"action": "reboot"}, {"action": 1}, {}, {"action": "evening", "extra": 1}): + for payload in ({"action": "order"}, {"action": "broadcast"}, {"action": "reboot"}, {"action": "sunset"}, {"action": 1}, {}, {"action": "drain", "extra": 1}): with self.subTest(payload=payload): self.assertEqual(self.post_json("/api/board/sign", payload, good)[0], 400) - self.assertEqual(self.post_json("/api/board/sign", {"action": "evening"}, self.client())[0], 403) + self.assertEqual(self.post_json("/api/board/sign", {"action": "drain"}, self.client())[0], 403) self.assertEqual(self.get("/api/board/sign")[0], 405) self.assertEqual(len(self.scripts.calls), 1) + def test_every_night_action_is_a_command_the_shipped_night_script_takes(self): + with tempfile.TemporaryDirectory() as tmp: + scripts = skill_scripts.Scripts(skills=REPO_ROOT / "skills", council=Path(tmp) / "council", home=Path(tmp)) + for action, (command, _) in messaging.NIGHTS.items(): + with self.subTest(action=action): + run = scripts.run(skill_scripts.NIGHT, [*command, "--session", "Operator"]) + self.assertEqual(run["code"], 0, run["stderr"]) + status = scripts.run(skill_scripts.NIGHT, ["status", "--session", "Operator"])["stdout"].splitlines() + self.assertEqual(status[0], "mode: day" if action == "resume" else f"mode: {action}") + def test_nl_actions_are_validated_against_a_faked_endpoint(self): status, _, body = self.post_json("/api/nl", {"text": "approve all"}, self.guard(self.host)) self.assertEqual(status, 400, body) diff --git a/tests/test_night.py b/tests/test_night.py index 6a111e2..28d9af6 100644 --- a/tests/test_night.py +++ b/tests/test_night.py @@ -1,4 +1,4 @@ -"""Exercise night.py: set, status per session, clear, and day on a bad state.""" +"""Exercise night.py: drain, suspend, status per session, resume, states from before the rename, and day on a bad state.""" from __future__ import annotations @@ -10,7 +10,7 @@ import unittest from pathlib import Path REPO_ROOT = Path(__file__).resolve().parents[1] -NIGHT = REPO_ROOT / "skills" / "kvb-org-sunset" / "scripts" / "night.py" +NIGHT = REPO_ROOT / "skills" / "kvb-org-suspend" / "scripts" / "night.py" class TestNight(unittest.TestCase): @@ -37,42 +37,62 @@ class TestNight(unittest.TestCase): self.assertEqual(result.returncode, 0, result.stderr) return result.stdout.splitlines() + def _state(self, state: dict) -> None: + self.root.mkdir(exist_ok=True) + (self.root / "night.json").write_text(json.dumps(state), encoding="utf-8") + def test_day_by_default(self): self.assertEqual(self._out("status", sid="s2"), ["mode: day"]) - def test_sunset_keeps_the_caller_active_and_sends_the_others_to_sleep(self): - self.assertEqual(self._out("set", "sunset"), ["s3\tThree", "s2\tTwo"]) + def test_suspend_keeps_the_caller_active_and_suspends_the_others(self): + self.assertEqual(self._out("suspend"), ["s3\tThree", "s2\tTwo"]) lines = self._out("status", sid="s2") - self.assertEqual(lines[:2], ["mode: sunset", "active: One s1"]) + self.assertEqual(lines[:2], ["mode: suspend", "active: One s1"]) self.assertRegex(lines[2], r"^since: \d{4}-\d\d-\d\dT") - self.assertEqual(lines[3], "you: sleep (kvb-agent-sleep)") + self.assertEqual(lines[3], "you: suspend (kvb-agent-suspend)") self.assertEqual(self._out("status")[3], "you: active") - self.assertEqual(self._out("status", "--session", "s3", sid=None)[3], "you: sleep (kvb-agent-sleep)") + self.assertEqual(self._out("status", "--session", "s3", sid=None)[3], "you: suspend (kvb-agent-suspend)") self.assertEqual(len(self._out("status", sid=None)), 3) - def test_evening_relaxes_and_clear_returns_to_day(self): - self._out("set", "evening", sid="s2") - self.assertEqual(self._out("status")[3], "you: relax (kvb-agent-relax)") - self.assertEqual(self._out("clear", sid="s2"), ["s1\tOne", "s3\tThree"]) + def test_drain_and_resume_return_to_day(self): + self._out("drain", sid="s2") + self.assertEqual(json.loads((self.root / "night.json").read_text(encoding="utf-8"))["mode"], "drain") + self.assertEqual(self._out("status")[3], "you: drain (kvb-agent-drain)") + self.assertEqual(self._out("resume", sid="s2"), ["s1\tOne", "s3\tThree"]) self.assertEqual(self._out("status"), ["mode: day"]) - def test_wake_lifts_one_session_until_the_next_set(self): - self.assertEqual(self._out("wake", sid="s2"), ["mode: day"]) - self._out("set", "sunset") - self.assertEqual(self._out("wake", sid="s2"), ["awake: s2"]) - self._out("wake", sid="s2") - self.assertEqual(json.loads((self.root / "night.json").read_text(encoding="utf-8"))["awake"], ["s2"]) - self.assertEqual(self._out("status", sid="s2")[3], "you: awake") - self.assertEqual(self._out("status", sid="s3")[3], "you: sleep (kvb-agent-sleep)") - self._out("set", "sunset") - self.assertEqual(self._out("status", sid="s2")[3], "you: sleep (kvb-agent-sleep)") + def test_resume_alone_lifts_one_session_until_the_next_suspend(self): + self.assertEqual(self._out("resume", "--alone", sid="s2"), ["mode: day"]) + self._out("suspend") + self.assertEqual(self._out("resume", "--alone", sid="s2"), ["resumed: s2"]) + self._out("resume", "--alone", sid="s2") + self.assertEqual(json.loads((self.root / "night.json").read_text(encoding="utf-8"))["resumed"], ["s2"]) + self.assertEqual(self._out("status", sid="s2")[3], "you: resumed") + self.assertEqual(self._out("status", sid="s3")[3], "you: suspend (kvb-agent-suspend)") + self._out("suspend") + self.assertEqual(self._out("status", sid="s2")[3], "you: suspend (kvb-agent-suspend)") + + def test_a_state_from_before_the_rename_keeps_working(self): + for old, new in (("evening", "drain"), ("sunset", "suspend")): + with self.subTest(old=old): + self._state({"mode": old, "active": "s1", "name": "One", "since": "2026-11-08T20:00:00+00:00", "awake": ["s3"]}) + self.assertEqual(self._out("status", sid="s2"), ["mode: " + new, "active: One s1", "since: 2026-11-08T20:00:00+00:00", f"you: {new} (kvb-agent-{new})"]) + self.assertEqual(self._out("status", sid="s3")[3], "you: resumed") + self.assertEqual(self._out("resume", "--alone", sid="s2"), ["resumed: s2"]) + state = json.loads((self.root / "night.json").read_text(encoding="utf-8")) + self.assertEqual((state["mode"], state["resumed"], "awake" in state), (new, ["s3", "s2"], False)) + self._state({"mode": "sunset", "active": "s1"}) + self.assertEqual(self._out("resume", sid="s2"), ["s1\tOne", "s3\tThree"]) + self.assertFalse((self.root / "night.json").exists()) def test_bad_state_means_day(self): self.root.mkdir() for text in ( "{not json", json.dumps({"mode": "noon", "active": "s1"}), - json.dumps(["sunset"]), + json.dumps({"mode": ["suspend"], "active": "s1"}), + json.dumps(["suspend"]), + json.dumps({"mode": "suspend", "active": "s1", "resumed": "s2"}), json.dumps({"mode": "sunset", "active": "s1", "awake": "s2"}), ): with self.subTest(text=text): @@ -82,8 +102,11 @@ class TestNight(unittest.TestCase): self.assertIn("treated as day", result.stderr) def test_usage_errors_exit_2(self): - self.assertEqual(self._run("set", "sunset", sid=None).returncode, 2) - self.assertEqual(self._run("set", "noon").returncode, 2) + self.assertEqual(self._run("suspend", sid=None).returncode, 2) + self.assertEqual(self._run("resume", "--alone", sid=None).returncode, 2) + for old in (("set", "sunset"), ("sunset",), ("evening",), ("clear",), ("wake",), ("noon",)): + with self.subTest(command=old): + self.assertEqual(self._run(*old).returncode, 2) self.assertFalse((self.root / "night.json").exists()) diff --git a/tests/test_night_names.py b/tests/test_night_names.py new file mode 100644 index 0000000..c119f58 --- /dev/null +++ b/tests/test_night_names.py @@ -0,0 +1,65 @@ +"""Pin decision 29: the six night skills renamed to drain, suspend and resume leave their old names nowhere but in a rename record.""" + +from __future__ import annotations + +import re +import subprocess +import unittest +from pathlib import Path + +REPO_ROOT = Path(__file__).resolve().parents[1] +RENAMED = { + "kvb-org-evening": "kvb-org-drain", + "kvb-org-sunset": "kvb-org-suspend", + "kvb-org-sunrise": "kvb-org-resume", + "kvb-agent-relax": "kvb-agent-drain", + "kvb-agent-sleep": "kvb-agent-suspend", + "kvb-agent-wakeup": "kvb-agent-resume", +} +OLD = re.compile(r"(? list[str]: + """Returns: + Every `path:line` of a tracked or new, not ignored text file that names + an old night skill outside a rename record (`old` → `new`, as decision + 29 of docs/requirements/001-agent-orchestrator.md writes it). + """ + listed = subprocess.run( + ["git", "ls-files", "-z", "--cached", "--others", "--exclude-standard"], + cwd=REPO_ROOT, capture_output=True, text=True, check=True, + ).stdout + hits = [] + for name in sorted(set(listed.split("\0")) - {"", SELF}): + try: + text = (REPO_ROOT / name).read_text(encoding="utf-8") + except (UnicodeDecodeError, IsADirectoryError, FileNotFoundError): + continue + for number, line in enumerate(text.splitlines(), 1): + if OLD.search(RECORD.sub("", line)): + hits.append(f"{name}:{number}") + return hits + + +class TestNightNames(unittest.TestCase): + def test_the_six_new_skills_exist_and_the_old_ones_do_not(self): + for old, new in RENAMED.items(): + with self.subTest(skill=new): + self.assertTrue((REPO_ROOT / "skills" / new / "SKILL.md").is_file()) + self.assertFalse((REPO_ROOT / "skills" / old).exists()) + + def test_old_names_live_only_in_rename_records(self): + self.assertEqual(old_name_lines(), [], "write a rename as `old` → `new`; any other mention goes") + + def test_a_rename_record_is_the_only_exemption(self): + self.assertIsNone(OLD.search(RECORD.sub("", "`kvb-org-sunset` → `kvb-org-suspend`"))) + for line in ("run kvb-agent-sleep now", "`kvb-org-sunset`", "kvb-org-sunset → kvb-org-suspend", "skills/kvb-org-sunrise/SKILL.md"): + with self.subTest(line=line): + self.assertIsNotNone(OLD.search(RECORD.sub("", line))) + self.assertIsNone(OLD.search("kvb-org-sunsets kvb-agent-sleeper my-kvb-org-evening")) + + +if __name__ == "__main__": + print("\n".join(old_name_lines())) diff --git a/tests/test_skill_cleanup.py b/tests/test_skill_cleanup.py index 3dd3667..939d869 100644 --- a/tests/test_skill_cleanup.py +++ b/tests/test_skill_cleanup.py @@ -12,6 +12,17 @@ from pathlib import Path REPO_ROOT = Path(__file__).resolve().parents[1] SCRIPT = REPO_ROOT / "skills" / "kvb-skill-cleanup" / "scripts" / "legacy.py" +REWORDED = """--- +name: {name} +description: probe +--- + +The probe keeps this first line as it is. +{name}: the first renamed line. +{name}: the second renamed line. +{name}: the third renamed line. +It keeps this closing line as it is too. +""" @unittest.skipUnless(shutil.which("git"), "git not installed") @@ -109,6 +120,24 @@ class TestLegacy(unittest.TestCase): ), ) + def test_a_rename_that_rewrites_its_name_throughout_keeps_its_successor(self): + (self.repo / "skills" / "night-old").mkdir() + (self.repo / "skills" / "night-old" / "SKILL.md").write_text(REWORDED.format(name="night-old"), encoding="utf-8") + self._commit(self.repo, "add night-old") + self._git(self.repo, "mv", "skills/night-old", "skills/kvb-x-night") + (self.repo / "skills" / "kvb-x-night" / "SKILL.md").write_text(REWORDED.format(name="kvb-x-night"), encoding="utf-8") + self._commit(self.repo, "rename night-old to kvb-x-night") + default = subprocess.run( + ["git", "diff", "-M", "--diff-filter=R", "--name-only", "HEAD~1", "HEAD"], + cwd=self.repo, env=self.env, capture_output=True, text=True, check=True, + ) + self.assertEqual(default.stdout.strip(), "", "the probe must stay below git's default rename similarity") + self._skill(self.home / "night-old") + result = self._run("--skills-repo", str(self.repo), "--root", str(self.home), "--json") + self.assertEqual(result.returncode, 0, result.stderr) + rows = {Path(row["path"]).name: (row["verdict"], row["successor"]) for row in json.loads(result.stdout)} + self.assertEqual(rows["night-old"], ("legacy", "kvb-x-night")) + def test_invalid_input_exits_2(self): missing = self._run("--skills-repo", str(self.repo), "--root", str(self.home / "nope")) self.assertEqual(missing.returncode, 2) From d9eb121d12882fa7b856ffb62d06b3d23cb4237f Mon Sep 17 00:00:00 2001 From: Kevin Veen-Birkenbach Date: Mon, 9 Nov 2026 06:53:55 +0000 Subject: [PATCH 6/7] feat(orchestrator): S5 Tasks with choices, Gantt, estimates and burn charts MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Requirement 001 phase 6, S5: - Tasks tab: every pending ask, rule request, operator row and choice card shows under "waits on Operator"; a choice request goes out on a fixed channel button, post and call with an agent multi-select, and a click on an option sends a passkey-signed answer the agent checks with operator_message. The unsigned /api/decisions//choose route is gone, and a decision, choice answer or choice recipient whose name holds "*" is refused, so a signed answer never reaches every agent. - Gantt view: one bar per task from start to end (running to now), one arrow per explicit, branch-base and queue-order edge, hatched forecast bars (always, points only, real only) from the median duration or points times median hours per point. - rasci.py set --after/--drop-after stores task dependencies and refuses unknown tasks and cycles. - Estimation toggle (No estimate default, Story points) is stored in the hub settings; burndown and burnup per whole register, list filter or one agent or line, counting tasks or summing complexity with the unestimated tasks as their own line. - New skill kvb-org-queue-estimate: "Request estimates" (story points mode, passkey-signed board action) or the skill sends exactly one newsletter listing every unestimated task with its RASCI parties; a party name that is no plain name shows as "unnamed party". - Business value per task or in bulk is stored only with a verified passkey assertion over the exact ids and values; WSJF uses it instead of the median. The task list sorts by every decision-50 mode both ways. - e2e: the walk's pending ask lives an hour instead of 60 s, and the CDP and BiDi drivers retry removing the browser profile while the browser exits (ENOTEMPTY). Evidence: make test 709 OK, ruff and markdownlint clean (/tmp/s5-make-test-fix-2.log); e2e 26 OK in Chromium and Firefox (/tmp/s5-e2e-fix-2.log); MEDUSA 50 files, an independent skeptic rejected four holes (unsigned choose route, unsigned estimates request, free-text party names, "*" recipients incl. normalizer bypasses), all fixed and re-verified, the 8 remaining pattern hits accepted, rescan 0 open. 🎯 Fix: 92 % 💥 Break: 4 % 💸 Cost: 100 % ⏱️ Time: – 🛡️ Security: 100 % 🏆 Score: 88 🚦 Gate: ✅ 90/5, cost and time <= 100, security 100 % Co-Authored-By: Claude Opus 5.5 --- README.md | 6 +- docs/requirements/001-agent-orchestrator.md | 26 +- orchestrator/client/signing.py | 8 +- orchestrator/kvb_orchestrator/approving.py | 13 +- orchestrator/kvb_orchestrator/asking.py | 29 +- orchestrator/kvb_orchestrator/choosing.py | 100 ++++ orchestrator/kvb_orchestrator/handler.py | 10 +- orchestrator/kvb_orchestrator/hub.py | 3 +- orchestrator/kvb_orchestrator/mcp.py | 14 +- orchestrator/kvb_orchestrator/messaging.py | 41 +- orchestrator/kvb_orchestrator/settings.py | 5 + .../kvb_orchestrator/skill_scripts.py | 1 + orchestrator/kvb_orchestrator/tasking.py | 8 +- orchestrator/kvb_orchestrator/tasks.py | 128 ++++- orchestrator/kvb_orchestrator/view.py | 10 +- orchestrator/templates/index.html.j2 | 6 + orchestrator/templates/nav.js | 4 +- orchestrator/templates/page-choices.js | 72 +++ orchestrator/templates/page-constants.js | 2 +- orchestrator/templates/page-inbox.js | 6 +- orchestrator/templates/page-screens.js | 3 +- orchestrator/templates/page-settings.js | 1 + orchestrator/templates/page-tasks-gantt.js | 216 +++++++++ orchestrator/templates/page-tasks-prio.js | 42 +- orchestrator/templates/page-tasks.js | 30 +- orchestrator/templates/plan.js | 176 +++++++ orchestrator/templates/style-tasks.css | 35 ++ skills/kvb-org-queue-estimate/SKILL.md | 24 + .../scripts/estimate.py | 94 ++++ skills/kvb-org-rasci/SKILL.md | 8 +- skills/kvb-org-rasci/scripts/rasci.py | 51 +- skills/kvb-org-wsjf/SKILL.md | 2 +- skills/kvb-think-choice/SKILL.md | 7 + tests/e2e/bidi.mjs | 2 +- tests/e2e/cdp.mjs | 2 +- tests/e2e/test_orchestrator_e2e.py | 449 +++++++++++++++++- tests/hub_support.py | 2 + tests/test_estimate.py | 86 ++++ tests/test_hub_asks.py | 22 +- tests/test_hub_board.py | 2 +- tests/test_hub_choices.py | 173 +++++++ tests/test_hub_inbox.py | 7 +- tests/test_hub_nav.py | 10 +- tests/test_hub_page.py | 8 +- tests/test_hub_plan.py | 150 ++++++ tests/test_hub_settings.py | 16 + tests/test_hub_state.py | 2 +- tests/test_hub_tasks.py | 149 +++++- tests/test_rasci.py | 49 ++ 49 files changed, 2162 insertions(+), 148 deletions(-) create mode 100644 orchestrator/kvb_orchestrator/choosing.py create mode 100644 orchestrator/templates/page-choices.js create mode 100644 orchestrator/templates/page-tasks-gantt.js create mode 100644 orchestrator/templates/plan.js create mode 100644 skills/kvb-org-queue-estimate/SKILL.md create mode 100755 skills/kvb-org-queue-estimate/scripts/estimate.py create mode 100644 tests/test_estimate.py create mode 100644 tests/test_hub_choices.py create mode 100644 tests/test_hub_plan.py diff --git a/README.md b/README.md index 623e55f..6481e8a 100644 --- a/README.md +++ b/README.md @@ -87,6 +87,7 @@ flowchart LR think --> think_choice[kvb-think-choice] org --> org_radio[kvb-org-radio] org --> org_queue[kvb-org-queue] + org --> org_queue_estimate[kvb-org-queue-estimate] org --> org_update[kvb-org-update] agent --> agent_optimize[kvb-agent-optimize] agent --> agent_drain[kvb-agent-drain] @@ -194,6 +195,7 @@ flowchart LR org_resume[kvb-org-resume] radio[kvb-org-radio] queue[kvb-org-queue] + queue_estimate[kvb-org-queue-estimate] org_update[kvb-org-update] end subgraph cat_agent [agent] @@ -411,11 +413,11 @@ The hub page loads nothing from the network: its icons come from Bootstrap Icons The Agents view "Hierarchy" draws the council's formal offices as a collapsible org chart: Operator, chair, dimensions with their line representatives, organisers (`cluster/`) and presidents (`work/`); the chair in every graph is the holder of the `chair` office, not a fixed name. Appointing, handing over or recalling an office there asks for the passkey signature; the hub writes a job (office, signed holder, successor session, work; no command) into `~/.local/state/kvb-orchestrator/offices/jobs`, and the `kvb-orchestrator-offices.path` user unit runs `client/offices.py` on the host, which verifies the signature, refuses a council directory others can write, a link on the path or a holder that changed since the signature. For a takeover or recall it moves the office aside and removes it only while the claim there still names the signed holder; an appoint or takeover then runs a plain `council.py claim ` for the successor by argv. council.py itself has no flag that overrides a live holder. The same view holds the operator's agent order as a drag list with up and down buttons: `rasci.py agents order` stores it in `agent-order.json` beside the register, where it breaks ties of equal task priority and orders the chair's grants without touching any task's `--prio` pin. -The Tasks tab (key 4, `#tasks/list`, `#tasks/board`, `#tasks/rasci`) shows the `kvb-org-rasci` register as a list, a board by status and a RASCI matrix; queue jobs from `council/queue.json` appear as "waiting for a grant", and the filter "Waiting for operator" is the inbox, which the Inbox entry under Stream opens. A task's sheet pins its priority (`rasci.py set --prio `) or sets and drops the operator's WSJF estimate (`rasci.py estimate Operator --value --complexity ` or `--drop`) after a passkey signature; the hub writes an argv-only job, and the runner, started with `--rasci --council `, verifies it like an operator command and runs `rasci.py` from `/` without a shell, killing it after 30 s. Agent order stays untouched. The install copies the fresh runner unit and restarts the runner when it is enabled, and only while the installed `council.py`, `nofollow.py` and `rasci.py` match this tree: otherwise it disables the runner and asks for `make install`. The runner unit pins `PATH` to `/usr/bin:/bin`, so a signed command names any other program by its full path; a runner started without `--rasci` and `--council` keeps running signed commands and refuses task changes, and so does one whose council is a symlink or another uid's. Each worktree in the tree file may carry `"flow": {"pull": [...], "push": [...], "source": "file"}` or `null`, which the Tree, the Chord edges, the detail panel and the matching task show; a malformed flow shows as `invalid`. Worktrees and tasks with open work (uncommitted, unpushed, unmerged, task not done) carry a warning bar. +The Tasks tab (key 4, `#tasks/list`, `#tasks/board`, `#tasks/rasci`) shows the `kvb-org-rasci` register as a list, a board by status and a RASCI matrix; queue jobs from `council/queue.json` appear as "waiting for a grant", and the filter "Waits on Operator" is the inbox, which the Inbox entry under Stream opens: every pending review, ask, rule request, operator row and choice card, with no Choices column of its own. "Request choices" has one button per channel, post and call to the agents ticked under "Agents", newsletter, broadcast, pan-pan, Sécurité and mayday to all, that sends the fixed request "send me your open decisions as choices" without a text field, one passkey assertion over every recipient (`/api/choices/sign`, then `/api/choices`). Agents answer with `decision_request`, shown as choice cards, and a click on an option is the passkey-signed answer: after the 3 s undo the hub verifies the signature and posts the answer to the asking agent, whose `decision_wait` returns it as `message` and `answer` for `operator_message`. A task's sheet pins its priority (`rasci.py set --prio `) or sets and drops the operator's WSJF estimate (`rasci.py estimate Operator --value --complexity ` or `--drop`) after a passkey signature; the hub writes an argv-only job, and the runner, started with `--rasci --council `, verifies it like an operator command and runs `rasci.py` from `/` without a shell, killing it after 30 s. Agent order stays untouched. The install copies the fresh runner unit and restarts the runner when it is enabled, and only while the installed `council.py`, `nofollow.py` and `rasci.py` match this tree: otherwise it disables the runner and asks for `make install`. The runner unit pins `PATH` to `/usr/bin:/bin`, so a signed command names any other program by its full path; a runner started without `--rasci` and `--council` keeps running signed commands and refuses task changes, and so does one whose council is a symlink or another uid's. Each worktree in the tree file may carry `"flow": {"pull": [...], "push": [...], "source": "file"}` or `null`, which the Tree, the Chord edges, the detail panel and the matching task show; a malformed flow shows as `invalid`. Worktrees and tasks with open work (uncommitted, unpushed, unmerged, task not done) carry a warning bar. Without reinstalling the skills, `make orchestrator-install` installs, builds and starts only the hub, `make orchestrator-check` checks the installed hub (image, container, logs, HTTP, pinned keys, hook, runner, tree timer, disk; exit 1 on a failure), `make orchestrator-pin CREDENTIAL=` pins the passkey that "Register passkey" shows, `make orchestrator-runner` enables the runner service, and `make orchestrator-hook` registers the PermissionRequest hook in `~/.claude/settings.json`, replacing an earlier Agent Orchestrator entry and keeping the file mode, after a copy to `settings.json.before-kvb-orchestrator-hook` (Claude Code reads `~/.claude/settings.local.json` only in sessions started in the home directory). Agents that reach the Docker socket are root-equivalent: until the agent VMs of core requirement 093 isolate them, the signatures do not hold against such an agent. `make watch-check` shows whether the resource watch hook is stuck (running hooks, holders of the kept queue history, age of the stored stage). -For approvals the hub is only a relay: every approval of an ask, a staged commit or an operator command is signed end to end with a WebAuthn passkey held in KeePassXC (through KeePassXC-Browser, relying party `localhost`, origin `http://localhost:`; ES256, EdDSA and RS256, so a hardware key can be pinned beside it). To register, open the hub at `http://localhost:/` (WebAuthn needs the domain; on `127.0.0.1` the page links there), choose "Register passkey" in the settings and run the host command the page shows, `python3 ~/.local/share/kvb-orchestrator/client/approval.py pin --port --approvers ~/.config/kvb-orchestrator/approvers.json --credential ''`, in a terminal outside every sandbox: it pins the key in `~/.config/kvb-orchestrator/approvers.json` with mode 0600, a file no sandboxed agent can write and the hub mounts read-only; the hub never pins. Each approval, or one bulk selection, is one signature over the hashes of every item, a nonce and an expiry; each auto-approval rule is signed once. In the inbox, an operator command run with "Run" shows the runner's output in a console under its row until "Close". "Deny" on an ask, an operator row or a rule request signs the denial with its channel and optional reason (a hash no approval shares) and, after the 3 s undo, tells the requesting agent by post or by the radio class picked, never mayday; the hub verifies that signature against the pinned keys before it stores or sends anything, the hook passes the reason on only when it verifies the signature too, and a denied operator row ends as `stopped`. Agents ask for an auto-approval rule with the MCP tool `rule_request` (the rules form's limits; a request stays open for the ask lifetime of one hour, at most 20 in all, and 3 per agent name, which only spreads the queue since MCP names no caller); its row shows a dry run over the last 7 days, and only "Accept" with the passkey stores it. The hub stores no rule, of any kind, whose passkey assertion it cannot verify. The executors verify it themselves against the pinned keys and fail closed: the runner (`client/runner.py`, the `kvb-orchestrator-runner` user service) runs only signed commands, each signature once, recorded in `~/.local/state/kvb-orchestrator-approvals/runner.json`; the PermissionRequest hook (`client/permission_hook.py --port --timeout --approvers ~/.config/kvb-orchestrator/approvers.json --replay ~/.local/state/kvb-orchestrator-approvals/hook.json`) allows only a signed item that matches its own tool, command, cwd and session, else it leaves the decision to Claude Code's own prompt; the commit skills run `approval.py verify` on the staged tree before committing, else they ask in the terminal. With no key pinned, every executor refuses; decisions and review rejections stay unsigned. A signed rule never covers a command holding `;`, `&`, `|`, a backtick, `$`, `<`, `>`, parentheses or a line break: such a command always asks. The hub page is trusted while it asks for a signature or shows the blob to pin: whoever controls the hub container can show one item and have another signed, or hand over a key of its own. Any local process, sandboxed agents included, can also send the unsigned operator actions (decision choices, the priority order, settings that add no stream origin, review rejections, the bare ask denial `/api/asks//deny`, console dismissals) with the hub's guard headers, and the container reads the host `/tmp` for the review pages in `/tmp/kvb-git-diff`. All three close with the agent VMs of core requirement 093, like the Docker-socket gap. +For approvals the hub is only a relay: every approval of an ask, a staged commit or an operator command is signed end to end with a WebAuthn passkey held in KeePassXC (through KeePassXC-Browser, relying party `localhost`, origin `http://localhost:`; ES256, EdDSA and RS256, so a hardware key can be pinned beside it). To register, open the hub at `http://localhost:/` (WebAuthn needs the domain; on `127.0.0.1` the page links there), choose "Register passkey" in the settings and run the host command the page shows, `python3 ~/.local/share/kvb-orchestrator/client/approval.py pin --port --approvers ~/.config/kvb-orchestrator/approvers.json --credential ''`, in a terminal outside every sandbox: it pins the key in `~/.config/kvb-orchestrator/approvers.json` with mode 0600, a file no sandboxed agent can write and the hub mounts read-only; the hub never pins. Each approval, or one bulk selection, is one signature over the hashes of every item, a nonce and an expiry; each auto-approval rule is signed once. In the inbox, an operator command run with "Run" shows the runner's output in a console under its row until "Close". "Deny" on an ask, an operator row or a rule request signs the denial with its channel and optional reason (a hash no approval shares) and, after the 3 s undo, tells the requesting agent by post or by the radio class picked, never mayday; the hub verifies that signature against the pinned keys before it stores or sends anything, the hook passes the reason on only when it verifies the signature too, and a denied operator row ends as `stopped`. Agents ask for an auto-approval rule with the MCP tool `rule_request` (the rules form's limits; a request stays open for the ask lifetime of one hour, at most 20 in all, and 3 per agent name, which only spreads the queue since MCP names no caller); its row shows a dry run over the last 7 days, and only "Accept" with the passkey stores it. The hub stores no rule, of any kind, whose passkey assertion it cannot verify. The executors verify it themselves against the pinned keys and fail closed: the runner (`client/runner.py`, the `kvb-orchestrator-runner` user service) runs only signed commands, each signature once, recorded in `~/.local/state/kvb-orchestrator-approvals/runner.json`; the PermissionRequest hook (`client/permission_hook.py --port --timeout --approvers ~/.config/kvb-orchestrator/approvers.json --replay ~/.local/state/kvb-orchestrator-approvals/hook.json`) allows only a signed item that matches its own tool, command, cwd and session, else it leaves the decision to Claude Code's own prompt; the commit skills run `approval.py verify` on the staged tree before committing, else they ask in the terminal. With no key pinned, every executor refuses; review rejections and a decision a rule takes stay unsigned. A signed rule never covers a command holding `;`, `&`, `|`, a backtick, `$`, `<`, `>`, parentheses or a line break: such a command always asks. The hub page is trusted while it asks for a signature or shows the blob to pin: whoever controls the hub container can show one item and have another signed, or hand over a key of its own. Any local process, sandboxed agents included, can also send the unsigned operator actions (the bare decision choice `/api/decisions//choose`, which sends no answer, the priority order, settings that add no stream origin, review rejections, the bare ask denial `/api/asks//deny`, console dismissals) with the hub's guard headers, and the container reads the host `/tmp` for the review pages in `/tmp/kvb-git-diff`. All three close with the agent VMs of core requirement 093, like the Docker-socket gap. Restart your agent afterwards so it loads the new skills. diff --git a/docs/requirements/001-agent-orchestrator.md b/docs/requirements/001-agent-orchestrator.md index ce9308e..d7a0c3a 100644 --- a/docs/requirements/001-agent-orchestrator.md +++ b/docs/requirements/001-agent-orchestrator.md @@ -619,11 +619,11 @@ flowchart TD ### Phase 6: Tasks with asks and choices (S5) -- [ ] Every pending ask, rule request, operator row and choice card shows in +- [x] Every pending ask, rule request, operator row and choice card shows in the Tasks tab under "waits on Operator"; no Choices column exists. -- [ ] Each channel button sends the fixed choice request with no text field; +- [x] Each channel button sends the fixed choice request with no text field; `post` and `call` take a multi-select of agents. -- [ ] A click on a choice option sends a passkey-signed answer the agent can +- [x] A click on a choice option sends a passkey-signed answer the agent can check with `operator_message`. ### Phase 6: Firewall (S6) @@ -656,31 +656,31 @@ flowchart TD ### Phase 6: Gantt, estimates, burndown and burnup (S5) -- [ ] `rasci.py set --after ` stores the dependency and +- [x] `rasci.py set --after ` stores the dependency and `--drop-after ` removes it; an unknown task and a cycle are refused. -- [ ] The Gantt view draws one bar per task from start to end, a running +- [x] The Gantt view draws one bar per task from start to end, a running task to now, and one arrow per explicit, branch-base and queue-order edge of a fixture register and queue. -- [ ] The forecast selector offers `always` (default), `points only` and +- [x] The forecast selector offers `always` (default), `points only` and `real only`; a hatched bar is as long as the median duration of done tasks (no estimate) or points times median hours per point (story points). -- [ ] The estimation toggle defaults to `No estimate`, is stored in the hub +- [x] The estimation toggle defaults to `No estimate`, is stored in the hub settings and survives a reload. -- [ ] Burndown and burnup offer the scopes whole register (default), list +- [x] Burndown and burnup offer the scopes whole register (default), list filter within the time window, and one agent or line; with no estimate they count tasks, with story points they sum complexity and draw the unestimated tasks as a line of their own. -- [ ] "Request estimates" shows only in story points mode; a click or +- [x] "Request estimates" shows only in story points mode; a click or `/kvb-org-queue-estimate` sends exactly one newsletter to all agents that lists every unestimated task with every party holding a RASCI role in it; a state build or a mode switch sends none. -- [ ] A per-task or bulk business value change is stored only with a +- [x] A per-task or bulk business value change is stored only with a verified passkey assertion over the exact task ids and values; a forged, replayed or altered batch changes nothing, and WSJF uses the operator value instead of the median. -- [ ] The task list sorts by each mode of decision 50 in both directions. +- [x] The task list sorts by each mode of decision 50 in both directions. ### Tests @@ -700,7 +700,7 @@ flowchart TD rename-once timeline, squelch scheduler, face generator, settings writer (forged, replayed, unlisted file), token sums, German text scan. - - [ ] S5 Gantt and estimates: dependency edges and cycle refusal, forecast lengths, burn + - [x] S5 Gantt and estimates: dependency edges and cycle refusal, forecast lengths, burn sums per mode and scope, newsletter body and its single send, bulk business value signature (forged, replayed, altered), sort orders. - **Integration** @@ -725,6 +725,6 @@ flowchart TD - [ ] Phase 6: no page scrollbar on any view, agent and node popups, choice request and signed answer, Firewall settings diff and signature, Resources charts, each at 1920, 1366 and 390 px. - - [ ] S5: Gantt with arrows, burndown and burnup, the estimation toggle, + - [x] S5: Gantt with arrows, burndown and burnup, the estimation toggle, "Request estimates" and a signed bulk business value change, each at 1920, 1366 and 390 px. diff --git a/orchestrator/client/signing.py b/orchestrator/client/signing.py index 260fd44..5579537 100644 --- a/orchestrator/client/signing.py +++ b/orchestrator/client/signing.py @@ -152,8 +152,9 @@ def task_argv(task: object, argv: object) -> list[str]: task: the register task the change is for, a rasci.py slug outside operator/. argv: the rasci.py arguments, one of `set --prio <1-999>`, - `estimate Operator --value --complexity ` or - `estimate Operator --drop`. + `estimate Operator --value --complexity `, + `estimate Operator --value ` (the operator's business + value alone) or `estimate Operator --drop`. Returns: argv, the hub and the runner check it the same way. @@ -167,7 +168,8 @@ def task_argv(task: object, argv: object) -> list[str]: raise Refused("the argv is no list of texts") rest = argv[3:] pinned = argv[:3] == ["set", task, "--prio"] and len(argv) == 4 and bool(PRIO.fullmatch(argv[3])) - estimated = len(rest) == 4 and rest[0] == "--value" and rest[1] in FIBONACCI and rest[2] == "--complexity" and rest[3] in FIBONACCI + valued = len(rest) in (2, 4) and rest[0] == "--value" and rest[1] in FIBONACCI + estimated = valued and (len(rest) == 2 or (rest[2] == "--complexity" and rest[3] in FIBONACCI)) if pinned or (argv[:3] == ["estimate", task, ESTIMATOR] and (estimated or rest == ["--drop"])): return argv raise Refused("the argv is no task priority or WSJF estimate change of this task") diff --git a/orchestrator/kvb_orchestrator/approving.py b/orchestrator/kvb_orchestrator/approving.py index 68ccf7e..64dc5ca 100644 --- a/orchestrator/kvb_orchestrator/approving.py +++ b/orchestrator/kvb_orchestrator/approving.py @@ -4,6 +4,7 @@ import secrets import time from .asking import ask_state +from .choosing import answer_signed from .cleanup import cleanup_request from .denying import DENIABLE, DENY_KEYS, denial_note, request_status, request_words from .errors import Conflict, Missing, ToolError @@ -35,7 +36,8 @@ def inbox_item(raw: dict, label: str, title: str, gate: str, subject: dict | Non label: the chosen option of a decision, else empty. title: what the stream logs for the item. gate: the review gate, else empty. - subject: what an approval signs; None for a decision. + subject: what an approval signs; for a decision the answer post to + the asking agent. requester: the requesting agent's name for a denial, else empty. Returns: @@ -105,14 +107,15 @@ class Approving: Returns: The proof to relay, None when nothing needs a signature. The hub verifies the signature of a denial itself, since it acts on it; - of an approval it checks the shape, and the executors verify. + of an approval it checks the shape, and the executors verify, + the hub itself for a choice answer when it sends it. """ if not signed: if proof is not None: raise ToolError("proof must be null when no item needs a signature") return None if not isinstance(proof, dict): - raise ToolError("not signed: an approval of an ask, review or operator command needs the passkey signature") + raise ToolError("not signed: an approval of an ask, review, choice or operator command needs the passkey signature") expect(proof, ("payload", "assertion")) try: payload = signing.checked_approval(proof["payload"], now) @@ -162,6 +165,8 @@ class Approving: record, changed = self.asks.decide(item["id"], {"status": "allowed" if approve else "denied", "proof": proof}) elif item["kind"] == "review": record, changed = self.reviews.decide(item["id"], {"status": "approved" if approve else "rejected", "proof": proof}) + elif item["signed"] is not None: + return self.answer_choice(item, proof) else: record, changed = self.decisions.decide(item["id"], {"status": "decided", "choice": item["label"]}) if record is None: @@ -218,7 +223,7 @@ class Approving: if kind_name == "rule": return inbox_item(raw, "", f"Rule {request_words(record)}", "", request_signed(record), self.requester(raw, record["agent"])) title = {"review": record.get("title"), "ask": f"{record.get('tool')} {record.get('command')}", "decision": record.get("question")}[kind_name] - subject = {"review": review_signed, "ask": ask_signed}[kind_name](record) if kind_name != "decision" else None + subject = {"review": review_signed, "ask": ask_signed}[kind_name](record) if kind_name != "decision" else answer_signed(record, label) return inbox_item(raw, label, title, record.get("gate", ""), subject, self.requester(raw, record["session"] if kind_name == "ask" else "")) def checked(self, raw: object) -> list[dict]: diff --git a/orchestrator/kvb_orchestrator/asking.py b/orchestrator/kvb_orchestrator/asking.py index 8128294..49ec1c5 100644 --- a/orchestrator/kvb_orchestrator/asking.py +++ b/orchestrator/kvb_orchestrator/asking.py @@ -2,6 +2,7 @@ from __future__ import annotations import time +from .choosing import EVERYONE, answer_text from .errors import Conflict, Missing, ToolError from .fields import ( COMMAND_LIMIT, @@ -35,7 +36,13 @@ def ask_row(ask: dict, names: dict[str, str]) -> dict: def decision_state(decision: dict) -> dict: - return {key: decision[key] for key in ("id", "status", "choice", "decided")} + """Returns: + The status and choice, with the id and text of the operator's + passkey-signed answer when a click chose it, else None for both. + """ + message = decision.get("message") + answer = None if message is None else answer_text(decision, decision["choice"]) + return {**{key: decision[key] for key in ("id", "status", "choice", "decided")}, "message": message, "answer": answer} def decision_row(decision: dict) -> dict: @@ -87,20 +94,7 @@ class Asking: if not changed: raise Conflict(ask_state(decided, time.time())) return ask_state(decided, time.time()) - if kind_name != "decisions" or verb != "choose": - raise Missing(verb) - payload = decode(body) - expect(payload, ("label",)) - label = field(payload, "label") - record = self.decisions.get(item_id) - if record is None: - raise Missing(item_id) - if label not in [option["label"] for option in record["options"]]: - raise ToolError(f"label must be one of the options of decision {item_id}") - decided, changed = self.decisions.decide(item_id, {"status": "decided", "choice": label}) - if not changed: - raise Conflict(decision_state(decided)) - return decision_state(decided) + raise Missing(verb) def decision_request(self, arguments: dict) -> dict: expect(arguments, ("question", "options", "agent", "recommended")) @@ -114,7 +108,10 @@ class Asking: recommended = arguments["recommended"] if not isinstance(recommended, str) or recommended.strip() not in ["", *(option["label"] for option in parsed)]: raise ToolError("recommended must be one of the option labels or an empty string") - fields = {"question": question, "options": parsed, "agent": field(arguments, "agent").strip(), "recommended": recommended.strip()} + asker = field(arguments, "agent").strip() + if EVERYONE in asker: + raise ToolError(f"agent names the asking agent, never a name with {EVERYONE}") + fields = {"question": question, "options": parsed, "agent": asker, "recommended": recommended.strip()} record = self.decisions.add({**fields, "status": "pending", "choice": None, "decided": None, "created_ts": time.time()}) self.automate("decision", record) return {"id": record["id"], "status": record["status"], "url": self.url()} diff --git a/orchestrator/kvb_orchestrator/choosing.py b/orchestrator/kvb_orchestrator/choosing.py new file mode 100644 index 0000000..a5b1038 --- /dev/null +++ b/orchestrator/kvb_orchestrator/choosing.py @@ -0,0 +1,100 @@ +from __future__ import annotations + +from .council import agent +from .errors import ToolError +from .fields import decode, expect, field +from .messaging import DIRECT, EVERYONE, TO_ALL +from .signed import signing + +CHOICE_REQUEST = "send me your open decisions as choices" +CHANNELS = {**DIRECT, **TO_ALL} +CHOICE_KEYS = ("class", "to") +RECIPIENT_LIMIT = 40 +ANSWER_CLASS = "post" +QUESTION_SHOWN = 200 + + +def answer_text(decision: dict, label: str) -> str: + question = " ".join(decision["question"].split())[:QUESTION_SHOWN] + return f"Choice for decision {decision['id']} ({question}): {label}" + + +def answer_signed(decision: dict, label: str) -> dict: + """Returns: + The post to the asking agent that a click on the option label + signs: the operator's answer operator_message proves. + """ + if EVERYONE in decision["agent"]: + raise ToolError(f"a choice answer goes to the asking agent, never to a name with {EVERYONE}") + return signing.message_item(agent(decision["agent"]), ANSWER_CLASS, answer_text(decision, label), "", "", "") + + +def recipients(payload: dict) -> list[str]: + """Args: + payload: the page's class and to: 1 to RECIPIENT_LIMIT distinct + agent names for post and call, [EVERYONE] for a class to all. + """ + cls, names = payload["class"], payload["to"] + if not isinstance(cls, str) or cls not in CHANNELS: + raise ToolError(f"class must be one of {', '.join(CHANNELS)}") + if not isinstance(names, list) or not all(isinstance(name, str) for name in names): + raise ToolError("to must be a list of agent names") + if cls in TO_ALL: + if names != [EVERYONE]: + raise ToolError(f"a choice request to all names to [{EVERYONE}]") + return names + targets = [field({"to": name}, "to").strip() for name in names] + if not 1 <= len(targets) <= RECIPIENT_LIMIT or any(EVERYONE in target for target in targets): + raise ToolError(f"a post or a call names 1 to {RECIPIENT_LIMIT} agents, never a name with {EVERYONE}") + if len({agent(target) for target in targets}) != len(targets): + raise ToolError("to must name distinct agents") + return targets + + +class Choosing: + def choice_items(self, payload: dict) -> list[dict]: + return [signing.message_item(target, payload["class"], CHOICE_REQUEST, "", "", "") for target in recipients(payload)] + + def sign_choices(self, body: bytes) -> dict: + payload = decode(body) + expect(payload, CHOICE_KEYS) + return self.challenge_for(self.choice_items(payload)) + + def request_choices(self, body: bytes) -> dict: + """Returns: + The ids of the stored requests, one per recipient, once one + passkey assertion signed each of them; nothing is stored or sent + before every item verified. + """ + payload = decode(body) + expect(payload, (*CHOICE_KEYS, "proof")) + items = self.choice_items(payload) + for item in items: + self.operator_proven(payload["proof"], item) + records = [self.stored_message(item, payload["proof"], None) for item in items] + runs = [self.radioed(record, CHANNELS[payload["class"]]) for record in records] + return {"ids": [record["id"] for record in records], "ok": all(run["code"] == 0 for run in runs), "runs": runs} + + def answer_choice(self, item: dict, proof: dict) -> str: + """Args: + item: a checked decision item whose signed is answer_signed(). + proof: the relayed signature; the hub sends the answer itself, + so it verifies the signature here, once. + + Returns: + The outcome words for the stream. + """ + record = self.decisions.get(item["id"]) + if record is None: + return "unknown" + if record["status"] != "pending": + return f"already {record['status']}" + self.operator_proven(proof, item["signed"]) + message = self.stored_message(item["signed"], proof, None) + decided, changed = self.decisions.decide(item["id"], {"status": "decided", "choice": item["label"], "message": message["id"]}) + if not changed: + self.messages.remove(message["id"]) + return f"already {decided['status']}" + run = self.radioed(message, CHANNELS[ANSWER_CLASS]) + where = f"{ANSWER_CLASS} to {message['address']}" + return f"decided · {where}" if run["code"] == 0 else f"decided · {where} failed ({run['code']})" diff --git a/orchestrator/kvb_orchestrator/handler.py b/orchestrator/kvb_orchestrator/handler.py index 40abc94..c272289 100644 --- a/orchestrator/kvb_orchestrator/handler.py +++ b/orchestrator/kvb_orchestrator/handler.py @@ -17,7 +17,7 @@ TTS_ROUTE = "/api/tts" WAV_TYPE = "audio/wav" STT_ROUTE = "/api/stt" ROUTE = re.compile(r"/reviews/([0-9a-f]{16})/(page|files|approve|reject)") -ITEM = re.compile(r"/api/(asks|decisions)/([0-9a-f]{16})(?:/(allow|deny|choose))?") +ITEM = re.compile(r"/api/(asks|decisions)/([0-9a-f]{16})(?:/(allow|deny))?") ENTRY = re.compile(r"/api/stream/([0-9]{1,12})") BOARD = re.compile(r"/api/board/([a-z-]{1,32})") UPLOADS = "/api/uploads" @@ -48,8 +48,10 @@ VOICE_ITEM = re.compile(r"/api/voice/([0-9a-f]{16})(\.wav)?") MESSAGE_SIGN_ROUTE = "/api/messages/sign" BOARD_SIGN_ROUTE = "/api/board/sign" SETTINGS_SIGN_ROUTE = "/api/settings/sign" +CHOICES_ROUTE = "/api/choices" +CHOICES_SIGN_ROUTE = "/api/choices/sign" WAV_POSTS = (STT_ROUTE, VOICE_ROUTE) -ACTION_POSTS = ("/api/rules", "/api/nl", SETTINGS_ROUTE, TTS_ROUTE, STT_ROUTE, SIGN_ROUTE, RULE_SIGN_ROUTE, CLEANUP_ROUTE, OFFICES_ROUTE, TASKS_ROUTE, VOICE_ROUTE, MESSAGE_SIGN_ROUTE, SETTINGS_SIGN_ROUTE) +ACTION_POSTS = ("/api/rules", "/api/nl", SETTINGS_ROUTE, TTS_ROUTE, STT_ROUTE, SIGN_ROUTE, RULE_SIGN_ROUTE, CLEANUP_ROUTE, OFFICES_ROUTE, TASKS_ROUTE, VOICE_ROUTE, MESSAGE_SIGN_ROUTE, SETTINGS_SIGN_ROUTE, CHOICES_ROUTE, CHOICES_SIGN_ROUTE) class Handler(Exchange): @@ -182,6 +184,10 @@ class Handler(Exchange): return lambda body: self.answer(lambda: hub.voice_notes.submit(body), HTTPStatus.ACCEPTED) if path == MESSAGE_SIGN_ROUTE: return lambda body: self.answer(lambda: hub.sign_message(body), HTTPStatus.OK) + if path == CHOICES_SIGN_ROUTE: + return lambda body: self.answer(lambda: hub.sign_choices(body), HTTPStatus.OK) + if path == CHOICES_ROUTE: + return lambda body: self.answer(lambda: hub.request_choices(body), HTTPStatus.CREATED) return None def posted(self, path: str) -> bool: diff --git a/orchestrator/kvb_orchestrator/hub.py b/orchestrator/kvb_orchestrator/hub.py index 4ed47a1..e9d49af 100644 --- a/orchestrator/kvb_orchestrator/hub.py +++ b/orchestrator/kvb_orchestrator/hub.py @@ -11,6 +11,7 @@ from .approving import Approving from .artifacts import Touched from .asking import Asking from .batches import Pending +from .choosing import Choosing from .cleanup import Cleaning, Spool from .denying import Denying from .engines import Engines, Speech @@ -62,7 +63,7 @@ def environment(templates: Path) -> jinja2.Environment: @dataclass(frozen=True) -class Hub(Mcp, Reviewing, Asking, Messaging, Approving, Denying, Requesting, Cleaning, Offices, Tasking, Inbox, Rules, Jobs, Sources, Timeline, View, Language): +class Hub(Mcp, Reviewing, Asking, Messaging, Choosing, Approving, Denying, Requesting, Cleaning, Offices, Tasking, Inbox, Rules, Jobs, Sources, Timeline, View, Language): council: Path pages: Path public_port: int diff --git a/orchestrator/kvb_orchestrator/mcp.py b/orchestrator/kvb_orchestrator/mcp.py index d476521..b90b5ac 100644 --- a/orchestrator/kvb_orchestrator/mcp.py +++ b/orchestrator/kvb_orchestrator/mcp.py @@ -5,6 +5,7 @@ from http import HTTPStatus from . import NAME from .asking import OPTION_LIMIT +from .choosing import CHOICE_REQUEST from .errors import RpcError, ToolError from .fields import WAIT_CAP from .requesting import AGENT_CAP @@ -64,19 +65,22 @@ class Mcp: tool("review_list", "List the pending reviews.", {}), tool( "decision_request", - "Ask the operator to pick one of several options in the Agent Orchestrator; each option becomes a button. " - "Returns the decision id and the hub URL.", + "Ask the operator to pick one of several options in the Agent Orchestrator; the question shows as a choice card " + "under Waits on Operator in the Tasks tab and each option becomes a button. When an operator message asks " + f'"{CHOICE_REQUEST}", send each open decision of kvb-think-choice through this tool. Returns the decision id and the hub URL.', { "question": text_property("The question, plain text."), "options": {"type": "array", "minItems": 1, "maxItems": OPTION_LIMIT, "items": option, "description": "The choices, at least one."}, - "agent": text_property("Your agent name, shown with the question."), + "agent": text_property("Your agent name, shown with the question; the operator's signed answer is a post to it."), "recommended": text_property("The label of the option you recommend, or an empty string."), }, ), tool( "decision_wait", - f"Wait until the operator picks an option or the timeout passes, then return the status " - f"(pending, decided) and the chosen label. Waits at most {WAIT_CAP} seconds.", + "Wait until the operator picks an option or the timeout passes, then return the status " + "(pending, decided), the chosen label and, for a click, message and answer: the id and text of the operator's " + "passkey-signed answer, a post to the asking agent; check it with operator_message(message, answer, your name) " + f"before acting on the choice. Waits at most {WAIT_CAP} seconds.", {"id": text_property("Decision id that decision_request returned."), "timeout_seconds": wait}, ), tool( diff --git a/orchestrator/kvb_orchestrator/messaging.py b/orchestrator/kvb_orchestrator/messaging.py index 865478b..2e1689b 100644 --- a/orchestrator/kvb_orchestrator/messaging.py +++ b/orchestrator/kvb_orchestrator/messaging.py @@ -5,12 +5,12 @@ import secrets import time from .council import HUMAN, agent, ordered, read_claims -from .errors import Missing, ToolError +from .errors import Conflict, Missing, ToolError from .fields import NAME_LIMIT, ORDER_NAME, decode, expect, field, message_text, single from .records import write_atomic from .register import REGISTER, agent_order, read_register from .signed import message_signed, signing -from .skill_scripts import NIGHT, RADIO, RASCI +from .skill_scripts import ESTIMATE, NIGHT, RADIO, RASCI NIGHTS = { "drain": (["drain"], "Operator ran kvb-org-drain in the Agent Orchestrator: run kvb-agent-drain; verify with night.py status."), @@ -23,7 +23,7 @@ TO_ALL = {"newsletter": ["post"], **{cls: ["send", cls] for cls in ("broadcast", EVERYONE = "*" DENIED = "Denied by the operator." MESSAGE_KEYS = ("to", "text", "upload", "class", "voice") -SIGNED_BOARD = ("clear-mayday", *NIGHTS) +SIGNED_BOARD = ("clear-mayday", *NIGHTS, "estimates") def chosen(payload: dict, choices: dict[str, list[str]]) -> list[str]: @@ -142,17 +142,31 @@ class Messaging: item, _, _ = self.composed(payload, {**DIRECT, **TO_ALL}) return self.challenge_for([item]) + def stored_message(self, item: dict, proof: dict, upload: dict | None) -> dict: + """Args: + item: the message item a pinned key signed. + proof: that signature, kept so operator_message can prove it. + upload: the attached upload or None. + + Returns: + The stored record, addressed to the radio address the claims + give the recipient. + """ + target = item["to"] + claims = read_claims(self.council) + address = next((claim["address"] for claim in claims if claim["agent"] == target and claim["address"]), target) + fields = {"to": target, "address": address, "text": item["text"], "upload": upload, "voice": item["voice"] or None, "voice_sha256": item["voice_sha256"], "class": item["class"]} + return self.messages.add({**fields, "proof": proof, "created_ts": time.time()}) + + def radioed(self, record: dict, command: list[str]) -> dict: + targets = [] if record["to"] == EVERYONE else ["--to", record["address"]] + return self.scripts.run(RADIO, [*command, *targets, "--session", HUMAN, f"[kvb-orchestrator msg {record['id']}] {self.relayed(record)}"]) + def relay(self, payload: dict, choices: dict[str, list[str]]) -> dict: with self.voice_notes.held(payload["voice"]): item, command, upload = self.composed(payload, choices) - proof = self.operator_proven(payload["proof"], item) - target = item["to"] - claims = read_claims(self.council) - address = next((claim["address"] for claim in claims if claim["agent"] == target and claim["address"]), target) - fields = {"to": target, "address": address, "text": item["text"], "upload": upload, "voice": item["voice"] or None, "voice_sha256": item["voice_sha256"], "class": item["class"]} - record = self.messages.add({**fields, "proof": proof, "created_ts": time.time()}) - targets = [] if target == EVERYONE else ["--to", address] - run = self.scripts.run(RADIO, [*command, *targets, "--session", HUMAN, f"[kvb-orchestrator msg {record['id']}] {self.relayed(record)}"]) + record = self.stored_message(item, self.operator_proven(payload["proof"], item), upload) + run = self.radioed(record, command) return {"id": record["id"], "ok": run["code"] == 0, "runs": [run]} def message(self, body: bytes) -> dict: @@ -191,6 +205,11 @@ class Messaging: if unknown: raise ToolError(f"unknown agents: {', '.join(unknown)[:300]}; the register and the council know {', '.join(known)[:600] or 'none'}") runs = [self.scripts.run(RASCI, ["agents", "order", ",".join(names)])] + elif action == "estimates": + estimation = self.settings.get()["estimation"] + if estimation != "points": + raise Conflict({"estimation": estimation, "reason": "estimates are requested only in story points mode"}) + runs = [self.scripts.run(ESTIMATE, ["request", "--session", HUMAN])] elif action in NIGHTS: command, text = NIGHTS[action] runs = [self.scripts.run(NIGHT, [*command, "--session", HUMAN])] diff --git a/orchestrator/kvb_orchestrator/settings.py b/orchestrator/kvb_orchestrator/settings.py index 0316225..a82f08e 100644 --- a/orchestrator/kvb_orchestrator/settings.py +++ b/orchestrator/kvb_orchestrator/settings.py @@ -14,6 +14,7 @@ from .fields import FIELDS, NAME_LIMIT, expect from .records import read_json, write_atomic THEMES = ("sky", "light", "dark", "custom") +ESTIMATIONS = ("none", "points") TONES = ("mayday", "review", "direct", "radio") COLOR = re.compile(r"#[0-9a-f]{6}") CLOCK = re.compile(r"(?:[01][0-9]|2[0-3]):[0-5][0-9]") @@ -44,6 +45,7 @@ SETTINGS = { "graph": {"axis": "none", "yaw": 30.0, "pitch": 20.0, "zoom": 1.0, "pan_x": 0.0, "pan_y": 0.0}, "sky": {"azimuth": 180.0, "altitude": 0.0, "fov": 180.0}, }, + "estimation": "none", } SPACE_AXES = ("none", "time", "spawn") SPACE_LIMITS = { @@ -189,6 +191,8 @@ def valid_settings(raw: object) -> dict: raise ToolError(f"theme must be one of {', '.join(THEMES)}") if not isinstance(data["streams"], list) or len(data["streams"]) > STREAMS_LIMIT: raise ToolError(f"streams must be a list of at most {STREAMS_LIMIT} entries") + if not isinstance(data["estimation"], str) or data["estimation"] not in ESTIMATIONS: + raise ToolError(f"estimation must be one of {', '.join(ESTIMATIONS)}") return { "latitude": number_in(data["latitude"], "latitude", -90.0, 90.0), "longitude": number_in(data["longitude"], "longitude", -180.0, 180.0), @@ -201,6 +205,7 @@ def valid_settings(raw: object) -> dict: "streams": [stream_entry(entry, index) for index, entry in enumerate(data["streams"])], "speech": speech_setting(data["speech"]), "space": space_setting(data["space"]), + "estimation": data["estimation"], } diff --git a/orchestrator/kvb_orchestrator/skill_scripts.py b/orchestrator/kvb_orchestrator/skill_scripts.py index 2eb9c46..d606d0b 100644 --- a/orchestrator/kvb_orchestrator/skill_scripts.py +++ b/orchestrator/kvb_orchestrator/skill_scripts.py @@ -13,6 +13,7 @@ RADIO = "kvb-org-radio/scripts/radio.py" RASCI = "kvb-org-rasci/scripts/rasci.py" NIGHT = "kvb-org-suspend/scripts/night.py" OPERATOR_SCRIPT = "kvb-org-operator/scripts/operator.py" +ESTIMATE = "kvb-org-queue-estimate/scripts/estimate.py" class Runner(Protocol): diff --git a/orchestrator/kvb_orchestrator/tasking.py b/orchestrator/kvb_orchestrator/tasking.py index b28c8a5..0180cba 100644 --- a/orchestrator/kvb_orchestrator/tasking.py +++ b/orchestrator/kvb_orchestrator/tasking.py @@ -9,7 +9,7 @@ from .register import REGISTER, read_register, status_of from .signed import signing from .tasks import editable -CHANGE_LIMIT = 10 +CHANGE_LIMIT = 100 CHANGE_KEYS = ("kind", "id", "argv") @@ -25,7 +25,9 @@ class Tasking: def task_changes(self, raw: object) -> list[dict]: """Args: raw: the page's items, each {"kind": "task", "id", "argv"} with - the rasci.py arguments of one priority pin or WSJF estimate. + the rasci.py arguments of one priority pin, WSJF estimate or + operator business value; a bulk change over a selection is + one item per task under one passkey assertion. Returns: The signed items, each for an open register task outside @@ -60,7 +62,7 @@ class Tasking: items = self.task_changes(payload["items"]) proof = self.covered(payload["proof"], items, time.time()) for item in items: - self.still_signed(proof, item) + self.operator_proven(proof, item) ids = [] for item in items: fields = {"kind": TASK_JOB, "task": item["id"], "argv": item["argv"], "command": shown_command(item["argv"]), "directory": "", "sha256": "", "status": "queued", "proof": proof} diff --git a/orchestrator/kvb_orchestrator/tasks.py b/orchestrator/kvb_orchestrator/tasks.py index e680e1a..15c9af2 100644 --- a/orchestrator/kvb_orchestrator/tasks.py +++ b/orchestrator/kvb_orchestrator/tasks.py @@ -3,8 +3,8 @@ from __future__ import annotations import itertools import statistics -from .council import agent -from .records import iso_epoch, shown +from .council import HUMAN, agent +from .records import epoch, iso_epoch, shown from .register import ENDED, OPERATOR, parties, register_row, status_of from .signed import signing from .tree import inside @@ -13,11 +13,13 @@ ENDED_SHOWN = 100 OPEN_SHOWN = 300 QUEUE_SHOWN = 100 PARTIES_SHOWN = 40 +AFTER_SHOWN = 40 TEXT_SHOWN = 500 FIBONACCI = (1, 2, 3, 5, 8, 13, 21, 34, 55, 89) LETTERS = "RASCI" HOTFIX = "hotfix/" QUEUE = "queue/" +HOUR = 3600 def kind_of(task: str) -> str: @@ -36,23 +38,42 @@ def fibonacci(value: object) -> bool: def estimates_of(row: dict) -> dict[str, dict]: + """Returns: + Each party's Fibonacci business value and complexity; the + Operator's complexity is None where it recorded a business value + alone. + """ raw = row.get("estimates") found = {} for party, entry in itertools.islice(raw.items(), PARTIES_SHOWN) if isinstance(raw, dict) else (): - if isinstance(entry, dict) and fibonacci(entry.get("value")) and fibonacci(entry.get("complexity")): - found[str(party)[:TEXT_SHOWN]] = {"value": entry["value"], "complexity": entry["complexity"]} + alone = party == HUMAN and isinstance(entry, dict) and "complexity" not in entry + if isinstance(entry, dict) and fibonacci(entry.get("value")) and (alone or fibonacci(entry.get("complexity"))): + found[str(party)[:TEXT_SHOWN]] = {"value": entry["value"], "complexity": entry.get("complexity")} return found +def business_value(estimates: dict[str, dict]) -> float | None: + if HUMAN in estimates: + return estimates[HUMAN]["value"] + return statistics.median(entry["value"] for entry in estimates.values()) if estimates else None + + +def points(estimates: dict[str, dict]) -> float | None: + sized = [entry["complexity"] for entry in estimates.values() if entry["complexity"] is not None] + return statistics.median(sized) if sized else None + + def wsjf(estimates: dict[str, dict]) -> dict | None: """Returns: - Median business value, median complexity and their quotient, the - same reading as rasci.py's wsjf(); None without an estimate. + Business value, median complexity and their quotient, the same + reading as rasci.py's wsjf(): the Operator's business value where + it gave one, else the median; None while no estimate carries a + complexity. """ - if not estimates: + complexity = points(estimates) + if complexity is None: return None - value = statistics.median(entry["value"] for entry in estimates.values()) - complexity = statistics.median(entry["complexity"] for entry in estimates.values()) + value = business_value(estimates) return {"value": value, "complexity": complexity, "score": round(value / complexity, 2)} @@ -96,6 +117,11 @@ def located(row: dict, trees: list[dict], open_task: bool) -> dict: return {"worktree": tree["path"], "worktree_branch": tree["branch"], "repo": tree["repo"], "flow": tree["flow"], "open_work": [*own, *tree["open_work"]]} +def after_of(row: dict) -> list[str]: + raw = row.get("after") + return [other for other in raw[:AFTER_SHOWN] if isinstance(other, str) and len(other) <= TEXT_SHOWN] if isinstance(raw, list) else [] + + def task_row(task: str, row: dict, trees: list[dict]) -> dict: estimates = estimates_of(row) ended = status_of(row) in ENDED @@ -108,6 +134,12 @@ def task_row(task: str, row: dict, trees: list[dict]) -> dict: "prio": prio_of(row), "estimates": estimates, "wsjf": wsjf(estimates), + "value": business_value(estimates), + "points": points(estimates), + "start": iso_epoch(row.get("start")), + "end": iso_epoch(row.get("end")) if ended else None, + "after": after_of(row), + "base": shown(row.get("base"))[:TEXT_SHOWN], "roles": roles_of(row), "queue": None, **located(row, trees, not ended), @@ -134,6 +166,12 @@ def queue_row(entry: dict, created: float, trees: list[dict]) -> dict: "prio": None, "estimates": {}, "wsjf": None, + "value": None, + "points": None, + "start": (epoch(entry.get("granted")) or created) if entry.get("status") == "active" else None, + "end": None, + "after": [], + "base": "-", "roles": {}, "queue": {"kind": text["kind"], "parent": text["task"], "enqueued": created}, **located(entry, trees, False), @@ -165,3 +203,75 @@ def task_rows(tasks: dict[str, dict], queue: list[tuple[dict, float]], scan: dic *(queue_row(entry, created, trees) for entry, created in jobs), *(task_row(task, tasks[task], trees) for task in ended[:ENDED_SHOWN]), ] + + +def register_ranks(tasks: dict[str, dict], agents: list[str]) -> dict[str, int]: + """Returns: + Each open task's index in rasci.py's ranked(): pin, WSJF, the + worker's place in the operator's agent order, then the name. + """ + order = {name: index for index, name in enumerate(agents)} + + def key(task: str) -> tuple: + worker = tasks[task].get("worker") + return (*rank(task, tasks[task])[:4], order.get(worker, len(order)) if isinstance(worker, str) else len(order), task) + + current = sorted((task for task, row in tasks.items() if status_of(row) not in ENDED), key=key) + return {task: index for index, task in enumerate(current)} + + +def queue_chain(queue: list[tuple[dict, float]], tasks: dict[str, dict], agents: list[str], now: float) -> list[tuple[str, bool]]: + """Args: + queue: the kvb-org-queue entries with their enqueue time. + tasks: the register rows by task. + agents: the operator's agent order. + now: epoch seconds. + + Returns: + The entry ids in grant order, each with whether it waits: the + active ones by grant time, then the waiting ones as queue.py's + ordered() sorts them (hotfix first, then the register rank less one + per whole hour waited, then the holder's agent order, then the + enqueue sequence). + """ + ranks = register_ranks(tasks, agents) + order = {name: index for index, name in enumerate(agents)} + + def waiting_key(pair: tuple[dict, float]) -> tuple: + entry, created = pair + task, name, seq = entry.get("task"), entry.get("name"), entry.get("seq") + hours = int((now - created) // HOUR) + place = ranks[task] if isinstance(task, str) and task in ranks else len(ranks) + holder = order[name] if isinstance(name, str) and name in order else len(order) + return (not entry.get("hotfix"), place - hours, holder, seq if isinstance(seq, int) and not isinstance(seq, bool) else 0) + + active = sorted((pair for pair in queue if pair[0].get("status") == "active"), key=lambda pair: epoch(pair[0].get("granted")) or pair[1]) + waiting = sorted((pair for pair in queue if pair[0].get("status") == "waiting"), key=waiting_key) + return [(shown(entry.get("id"))[:TEXT_SHOWN], entry.get("status") == "waiting") for entry, _ in [*active, *waiting]] + + +def branch_of(row: dict) -> str: + return row["branch"] if row["branch"] != "-" else row["worktree_branch"] + + +def task_edges(rows: list[dict], chain: list[tuple[str, bool]]) -> list[dict]: + """Args: + rows: the shown task rows of task_rows(). + chain: queue_chain(). + + Returns: + One {"from", "to", "kind"} edge per predecessor among the shown + rows: kind after for an explicit `rasci.py set --after`, base for a + task whose base branch is another task's branch, queue for each + waiting queue job and the job ahead of it. + """ + shown_tasks = {row["task"] for row in rows} + edges = [{"from": other, "to": row["task"], "kind": "after"} for row in rows for other in row["after"] if other in shown_tasks and other != row["task"]] + branches: dict[str, list[str]] = {} + for row in rows: + if row["kind"] != "queue" and branch_of(row): + branches.setdefault(branch_of(row), []).append(row["task"]) + edges += [{"from": other, "to": row["task"], "kind": "base"} for row in rows if row["kind"] != "queue" for other in branches.get(row["base"], []) if other != row["task"]] + jobs = [(f"{QUEUE}{job}", waits) for job, waits in chain] + edges += [{"from": ahead, "to": job, "kind": "queue"} for (ahead, _), (job, waits) in itertools.pairwise(jobs) if waits and {ahead, job} <= shown_tasks] + return edges diff --git a/orchestrator/kvb_orchestrator/view.py b/orchestrator/kvb_orchestrator/view.py index cd2ff70..5637fea 100644 --- a/orchestrator/kvb_orchestrator/view.py +++ b/orchestrator/kvb_orchestrator/view.py @@ -36,7 +36,7 @@ from .reviewing import review_row from .settings import media_origins, station_origins, valid_settings from .signed import signing from .skill_scripts import OUTPUT_LIMIT -from .tasks import task_rows +from .tasks import queue_chain, task_edges, task_rows RADIO_WINDOW = 86400 JOBS_SHOWN = 20 @@ -103,6 +103,9 @@ class View: people = {node["id"]: {"name": node["label"], "now": directory.now(node["id"]) or node["label"], "names": node["names"]} for node in drawn["nodes"] if node["kind"] != "subagent"} settings = self.settings.get() inbox = self.inbox(now, tasks, directory) + queue = queue_entries(self.council) + order = stored_order(self.council / AGENT_ORDER) + rows = task_rows(tasks, queue, self.tree.get()) return { "settings": settings, "media": media_origins(settings), @@ -128,8 +131,9 @@ class View: "messages": [message_row(message) for message in self.messages.listed() if begin <= message["created_ts"] <= end], "operator": operator_rows(tasks), "register": register_rows(tasks), - "tasks": task_rows(tasks, queue_entries(self.council), self.tree.get()), - "agent_order": agent_order(tasks, claims, stored_order(self.council / AGENT_ORDER)), + "tasks": rows, + "task_edges": task_edges(rows, queue_chain(queue, tasks, order, now)), + "agent_order": agent_order(tasks, claims, order), "radio": radio, "claims": claims, "grants": grant_rows, diff --git a/orchestrator/templates/index.html.j2 b/orchestrator/templates/index.html.j2 index 4a6db0d..de073f7 100644 --- a/orchestrator/templates/index.html.j2 +++ b/orchestrator/templates/index.html.j2 @@ -453,6 +453,8 @@ pre.notes { margin: 0; padding: 8px 10px; background: var(--sunken); border-radi {% include "popup.js" %} {% include "faces.js" %} + +{% include "plan.js" %} ", "")) self.assertEqual((state["register"][0]["title"], state["radio"][0]["from"]), ("", "")) - def test_the_index_scripts_parse_and_embed_the_ambience_voice_nav_popup_faces_and_space_modules(self): + def test_the_index_scripts_parse_and_embed_the_ambience_voice_nav_popup_faces_plan_and_space_modules(self): html = self.index() - for module in (AMBIENCE, VOICE, NAV, POPUP, FACES, SPACE): + for module in (AMBIENCE, VOICE, NAV, POPUP, FACES, PLAN, SPACE): with self.subTest(module=module.name): self.assertIn(module.read_text(encoding="utf-8").strip(), html) scripts = re.findall(r'', html, re.DOTALL) @@ -74,7 +74,7 @@ class TestHubPage(HubCase): page.write_text("\n;\n".join(scripts), encoding="utf-8") done = subprocess.run(["node", "--check", str(page)], capture_output=True, text=True, timeout=60, check=False) self.assertEqual(done.returncode, 0, done.stderr) - for module in (AMBIENCE, VOICE, NAV, POPUP, FACES, SPACE): + for module in (AMBIENCE, VOICE, NAV, POPUP, FACES, PLAN, SPACE): with self.subTest(module=module.name): done = subprocess.run(["node", "--check", str(module)], capture_output=True, text=True, timeout=60, check=False) self.assertEqual(done.returncode, 0, done.stderr) diff --git a/tests/test_hub_plan.py b/tests/test_hub_plan.py new file mode 100644 index 0000000..5c0c833 --- /dev/null +++ b/tests/test_hub_plan.py @@ -0,0 +1,150 @@ +from __future__ import annotations + +import json +import subprocess +import unittest + +from hub_support import PLAN + +HOUR = 3600 +NOW = 100 * HOUR +PLAN_PROBE = """ +const P = require(process.argv[1]); +const H = 3600; +const now = 100 * H; +const row = (task, fields) => ({task, kind: "task", status: "queued", ended: false, start: null, end: null, points: null, wsjf: null, value: null, worker: "-", title: "-", roles: {}, ...fields}); +const rows = [ + row("work/a", {status: "done", ended: true, start: 80 * H, end: 82 * H, points: 2, worker: "Skills"}), + row("work/b", {status: "done", ended: true, start: 84 * H, end: 88 * H, points: 2, roles: {Stage: "R"}}), + row("work/c", {status: "done", ended: true, start: 90 * H, end: 91 * H}), + row("work/run", {status: "running", start: 95 * H, points: 5, worker: "Stage"}), + row("work/next", {points: 3}), + row("work/tail", {}), + row("work/stop", {status: "stopped", ended: true, start: 85 * H, end: 86 * H, points: 1}), + row("queue/x", {kind: "queue", status: "awaiting"}), + row("operator/push", {kind: "command", status: "done", ended: true, end: 70 * H}), +]; +const edges = [ + {from: "work/run", to: "work/next", kind: "after"}, + {from: "work/next", to: "work/tail", kind: "after"}, + {from: "work/c", to: "work/tail", kind: "base"}, + {from: "work/run", to: "queue/x", kind: "queue"}, + {from: "work/gone", to: "work/tail", kind: "base"}, +]; +const loop = [row("loop/a", {}), row("loop/b", {})]; +const looped = [{from: "loop/a", to: "loop/b", kind: "base"}, {from: "loop/b", to: "loop/a", kind: "queue"}]; +const lay = (estimation, forecast) => P.bars(rows, edges, {now, estimation, forecast}).map((bar) => [bar.task, bar.start / H, bar.end / H, bar.forecast, bar.dot]); +const sorts = [ + row("t1", {wsjf: {score: 2}, value: 8, points: 3, status: "running", start: 5, worker: "Bravo", title: "Zulu"}), + row("t2", {status: "done", start: 3, end: 9}), + row("t3", {wsjf: {score: 5}, value: 3, points: 1, worker: "alpha", title: "Alpha"}), + row("t4", {wsjf: {score: 2}, value: 13, points: 8, status: "blocked", start: 1, end: 4, worker: "Charlie", title: "mike"}), +]; +const context = {filtered: [rows[0], rows[7]], since: 90 * H, until: 99 * H, now, holders: {"identity/oidc": "Stage"}}; +const scope = (choice) => { + const found = P.scoped(rows, choice, context); + return {tasks: found.rows.map((entry) => entry.task), from: found.from / H, to: found.to / H}; +}; +const series = (estimation) => P.burn(P.scoped(rows, "all", context).rows, {estimation, from: 70 * H, to: now}).points.map((point) => [point.t / H, point.scope, point.done, point.remaining, point.unestimated]); +console.log(JSON.stringify({ + options: [P.FORECASTS, P.ESTIMATIONS, P.SORTS.map(([id]) => id), P.SERIES], + medians: P.medians(rows), + median: [P.median([]), P.median([3, 1, 2]), P.median([4, 1, 3, 2])], + bars: {noneAlways: lay("none", "always"), pointsAlways: lay("points", "always"), pointsOnly: lay("points", "points"), noneOnly: lay("none", "points"), real: lay("points", "real")}, + loop: P.bars(loop, looped, {now, estimation: "none", forecast: "always"}).map((bar) => bar.task), + empty: P.bars([row("work/new", {}), row("work/gone", {status: "done", ended: true})], [], {now, estimation: "none", forecast: "always"}), + scopes: {all: scope("all"), filter: scope("filter"), agent: scope("agent:Stage"), line: scope("line:identity/oidc"), none: scope("agent:Nobody")}, + burn: {none: series("none"), points: series("points")}, + sorted: Object.fromEntries(P.SORTS.map(([id]) => [id, [P.sortRows(sorts, id, false).map((entry) => entry.task), P.sortRows(sorts, id, true).map((entry) => entry.task)]])), + unknown: P.sortRows(sorts, "nope", false).map((entry) => entry.task), +})); +""" + + +class TestPlanModule(unittest.TestCase): + @classmethod + def setUpClass(cls): + done = subprocess.run(["node", "-e", PLAN_PROBE, str(PLAN)], capture_output=True, text=True, timeout=60, check=True) + cls.data = json.loads(done.stdout) + + def test_the_selectors_offer_the_forecasts_estimations_sort_modes_and_series(self): + forecasts, estimations, sorts, series = self.data["options"] + self.assertEqual(forecasts, [["always", "always"], ["points", "points only"], ["real", "real only"]]) + self.assertEqual(estimations, [["none", "No estimate"], ["points", "Story points"]]) + self.assertEqual(sorts, ["prio", "wsjf", "value", "complexity", "status", "start", "end", "agent", "title"]) + self.assertEqual(series, ["scope", "done", "remaining", "unestimated"]) + + def test_medians_take_done_tasks_only_and_the_points_of_those_with_points(self): + self.assertEqual(self.data["medians"], {"duration": 2 * HOUR, "perPoint": 1.5 * HOUR}) + self.assertEqual(self.data["median"], [None, 2, 2.5]) + + def test_without_estimate_a_forecast_is_as_long_as_the_median_duration_behind_its_predecessors(self): + self.assertEqual(self.data["bars"]["noneAlways"], [ + ["work/a", 80, 82, False, False], + ["work/b", 84, 88, False, False], + ["work/c", 90, 91, False, False], + ["work/run", 95, 100, False, False], + ["work/next", 100, 102, True, False], + ["work/tail", 102, 104, True, False], + ["work/stop", 85, 86, False, False], + ["queue/x", 100, 102, True, False], + ["operator/push", 70, 70, False, True], + ]) + + def test_with_story_points_a_forecast_is_points_times_the_median_hours_per_point(self): + bars = {task: rest for task, *rest in self.data["bars"]["pointsAlways"]} + self.assertEqual(bars["work/next"], [100, 104.5, True, False]) + self.assertEqual(bars["work/tail"], [104.5, 106.5, True, False]) + + def test_points_only_draws_a_dot_behind_the_predecessors_of_a_task_without_estimate(self): + only = {task: rest for task, *rest in self.data["bars"]["pointsOnly"]} + self.assertEqual((only["work/next"], only["work/tail"], only["queue/x"]), ([100, 104.5, True, False], [104.5, 104.5, True, True], [100, 100, True, True])) + none = {task: rest for task, *rest in self.data["bars"]["noneOnly"]} + self.assertEqual((none["work/next"], none["work/tail"]), ([100, 100, True, True], [100, 100, True, True])) + + def test_real_only_draws_no_forecast(self): + self.assertEqual([task for task, *_ in self.data["bars"]["real"]], ["work/a", "work/b", "work/c", "work/run", "work/stop", "operator/push"]) + self.assertFalse(any(bar[3] for bar in self.data["bars"]["real"])) + + def test_a_cycle_still_draws_every_task_no_done_task_means_a_dot_and_an_ended_task_without_times_no_bar(self): + self.assertEqual(self.data["loop"], ["loop/a", "loop/b"]) + self.assertEqual(self.data["empty"], [{"task": "work/new", "start": NOW, "end": NOW, "forecast": True, "dot": True}]) + + def test_the_scopes_are_the_whole_register_the_filter_in_its_window_and_one_agent_or_line(self): + work = ["work/a", "work/b", "work/c", "work/run", "work/next", "work/tail", "work/stop"] + scopes = self.data["scopes"] + self.assertEqual(scopes["all"], {"tasks": work, "from": 80, "to": 100}) + self.assertEqual(scopes["filter"], {"tasks": ["work/a"], "from": 90, "to": 99}) + self.assertEqual(scopes["agent"], {"tasks": ["work/b", "work/run"], "from": 84, "to": 100}) + self.assertEqual(scopes["line"], scopes["agent"]) + self.assertEqual(scopes["none"], {"tasks": [], "from": 76, "to": 100}) + + def test_without_estimate_the_burn_counts_tasks(self): + self.assertEqual(self.data["burn"]["none"], [ + [70, 2, 0, 2, 0], [80, 3, 0, 3, 0], [82, 3, 1, 2, 0], [84, 4, 1, 3, 0], [85, 5, 1, 4, 0], [86, 4, 1, 3, 0], + [88, 4, 2, 2, 0], [90, 5, 2, 3, 0], [91, 5, 3, 2, 0], [95, 6, 3, 3, 0], [100, 6, 3, 3, 0], + ]) + + def test_with_story_points_the_burn_sums_complexity_and_counts_the_unestimated_apart(self): + burn = self.data["burn"]["points"] + self.assertEqual(burn[0], [70, 3, 0, 3, 1]) + self.assertEqual(burn[-1], [100, 12, 4, 8, 1]) + self.assertEqual([point[4] for point in burn], [1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1]) + + def test_the_list_sorts_by_every_mode_in_both_directions_with_missing_keys_last(self): + self.assertEqual(self.data["sorted"], { + "prio": [["t1", "t2", "t3", "t4"], ["t4", "t3", "t2", "t1"]], + "wsjf": [["t1", "t4", "t3", "t2"], ["t3", "t1", "t4", "t2"]], + "value": [["t3", "t1", "t4", "t2"], ["t4", "t1", "t3", "t2"]], + "complexity": [["t3", "t1", "t4", "t2"], ["t4", "t1", "t3", "t2"]], + "status": [["t3", "t1", "t4", "t2"], ["t2", "t4", "t1", "t3"]], + "start": [["t4", "t2", "t1", "t3"], ["t1", "t2", "t4", "t3"]], + "end": [["t4", "t2", "t1", "t3"], ["t2", "t4", "t1", "t3"]], + "agent": [["t3", "t1", "t4", "t2"], ["t4", "t1", "t3", "t2"]], + "title": [["t3", "t4", "t2", "t1"], ["t1", "t2", "t4", "t3"]], + }) + self.assertEqual(self.data["unknown"], ["t1", "t2", "t3", "t4"]) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_hub_settings.py b/tests/test_hub_settings.py index cbd9739..1f0ed8b 100644 --- a/tests/test_hub_settings.py +++ b/tests/test_hub_settings.py @@ -150,6 +150,22 @@ class TestHubSettings(HubCase): self.assertEqual(status, 200, body) self.assertEqual(json.loads(body)["settings"]["speech"], {"on": False, "classes": ["broadcast", "mayday", "security"], "muted": ["Operator", "name:Docs", "s1"]}) + def test_the_estimation_mode_defaults_to_no_estimate_is_stored_and_survives_a_reload(self): + self.assertEqual((settings.SETTINGS["estimation"], self.snapshot()["settings"]["estimation"]), ("none", "none")) + good = self.guard(self.host) + for wrong in ("Story points", "", None, 1, ["points"]): + with self.subTest(wrong=wrong): + self.assertEqual(self.post_json("/api/settings", {**settings.SETTINGS, "estimation": wrong}, good)[0], 400) + self.assertEqual(self.post_json("/api/settings", {key: value for key, value in settings.SETTINGS.items() if key != "estimation"}, good)[0], 400) + status, _, body = self.save({**self.snapshot()["settings"], "estimation": "points"}, self.pin()) + self.assertEqual((status, json.loads(body)["settings"]["estimation"]), (200, "points")) + self.assertEqual(json.loads((self.state / "settings.json").read_text(encoding="utf-8"))["estimation"], "points") + self.assertEqual(settings.Settings(self.state / "settings.json").get()["estimation"], "points") + self.assertEqual(self.snapshot()["settings"]["estimation"], "points") + older = {key: value for key, value in self.settings_payload(STREAMS).items() if key != "estimation"} + (self.state / "settings.json").write_text(json.dumps(older), encoding="utf-8") + self.assertEqual(settings.Settings(self.state / "settings.json").get()["estimation"], "none") + def test_settings_written_before_the_radio_filter_keep_their_values(self): older = {key: value for key, value in self.settings_payload(STREAMS).items() if key != "speech"} (self.state / "settings.json").write_text(json.dumps(older), encoding="utf-8") diff --git a/tests/test_hub_state.py b/tests/test_hub_state.py index 8ad6aea..fddd2bb 100644 --- a/tests/test_hub_state.py +++ b/tests/test_hub_state.py @@ -151,7 +151,7 @@ class TestHubState(HubCase): set(state), { "now", "since", "until", "first", "alarm_since", "reviews", "asks", "decisions", "messages", "operator", - "register", "tasks", "agent_order", "radio", "claims", "grants", "night", "silence", "graph", + "register", "tasks", "task_edges", "agent_order", "radio", "claims", "grants", "night", "silence", "graph", "inbox", "pending", "rules", "approvers", "jobs", "views", "llm", "people", "settings", "media", "speech", "badges", "kinds", }, diff --git a/tests/test_hub_tasks.py b/tests/test_hub_tasks.py index 52c4fa8..1807a4d 100644 --- a/tests/test_hub_tasks.py +++ b/tests/test_hub_tasks.py @@ -1,5 +1,6 @@ from __future__ import annotations +import importlib.util import json import os import signal @@ -10,19 +11,31 @@ from pathlib import Path from unittest import mock from hub_case import HubCase -from hub_support import runner, signing, verifier -from kvb_orchestrator import skill_scripts, tasks, tree +from hub_support import REPO_ROOT, iso, key, runner, signing, verifier +from kvb_orchestrator import settings, skill_scripts, tasks, tree BROKEN = {"pull": [], "push": [], "source": "invalid"} FLOW = {"pull": ["origin/main", "store-i18n"], "push": ["main", "production"], "source": "file"} PRIO = ["set", "work/feature", "--prio", "3"] ESTIMATE = ["estimate", "work/feature", "Operator", "--value", "8", "--complexity", "3"] +QUEUE_SCRIPT = REPO_ROOT / "skills" / "kvb-org-queue" / "scripts" / "queue.py" def change(argv: list, task: str = "work/feature") -> dict: return {"kind": "task", "id": task, "argv": argv} +def valued(task: str, value: str) -> dict: + return change(["estimate", task, "Operator", "--value", value], task) + + +def load_queue(): + spec = importlib.util.spec_from_file_location("queue_for_the_hub_chain", QUEUE_SCRIPT) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + class TestHubTasks(HubCase): def places(self) -> tuple[str, str, str]: root = self.write_tree() @@ -307,6 +320,138 @@ class TestHubTasks(HubCase): self.assertEqual((len(rows[0]["estimates"]), len(rows[0]["roles"])), (2, 2)) self.assertEqual(max(len(row["task"]) for row in self.snapshot()["tasks"]), tasks.TEXT_SHOWN) + def plan_register(self, now: float) -> tuple[dict, dict]: + register = { + "work/base": {"status": "done", "branch": "feature/base", "start": iso(now - 7200), "end": iso(now - 3600)}, + "work/child": {"status": "queued", "base": "feature/base"}, + "work/next": {"status": "queued", "after": ["work/child", "work/gone", "work/next", 7]}, + "work/side": {"status": "running", "branch": "side", "base": "feature/base", "start": iso(now - 600)}, + "work/pinned": {"status": "queued", "prio": 1}, + } + entries = [ + {"id": "deploy-1", "seq": 1, "kind": "deploy", "task": "work/side", "name": "Stage", "hotfix": None, "status": "active", "enqueued": now - 200, "granted": now - 100, "cmd": "make deploy"}, + {"id": "gate-2", "seq": 2, "kind": "gate", "task": "work/next", "name": "Docs", "hotfix": None, "status": "waiting", "enqueued": now - 50, "granted": None, "cmd": "make test"}, + {"id": "gate-3", "seq": 3, "kind": "gate", "task": "work/pinned", "name": "Docs", "hotfix": None, "status": "waiting", "enqueued": now - 40, "granted": None, "cmd": "make test"}, + {"id": "hot-4", "seq": 4, "kind": "gate", "task": "work/next", "name": "Docs", "hotfix": "db", "status": "waiting", "enqueued": now - 30, "granted": None, "cmd": "make test"}, + {"id": "old-5", "seq": 5, "kind": "gate", "task": "work/next", "name": "Stage", "hotfix": None, "status": "waiting", "enqueued": now - 7210, "granted": None, "cmd": "make test"}, + ] + return register, {"seq": 5, "entries": entries} + + def test_edges_come_from_explicit_dependencies_branch_bases_and_the_queue_order(self): + now = time.time() + register, queue = self.plan_register(now) + self.write_council({"rasci.json": register, "queue.json": queue}) + state = self.snapshot() + self.assertEqual(state["task_edges"], [ + {"from": "work/child", "to": "work/next", "kind": "after"}, + {"from": "work/base", "to": "work/child", "kind": "base"}, + {"from": "work/base", "to": "work/side", "kind": "base"}, + {"from": "queue/deploy-1", "to": "queue/hot-4", "kind": "queue"}, + {"from": "queue/hot-4", "to": "queue/gate-3", "kind": "queue"}, + {"from": "queue/gate-3", "to": "queue/old-5", "kind": "queue"}, + {"from": "queue/old-5", "to": "queue/gate-2", "kind": "queue"}, + ]) + rows = {row["task"]: row for row in state["tasks"]} + self.assertEqual((rows["work/next"]["after"], rows["work/child"]["base"], rows["work/pinned"]["base"]), (["work/child", "work/gone", "work/next"], "feature/base", "-")) + self.assertAlmostEqual(rows["work/base"]["start"], now - 7200, places=3) + self.assertAlmostEqual(rows["work/base"]["end"], now - 3600, places=3) + self.assertIsNone(rows["work/side"]["end"]) + self.assertEqual((rows["queue/deploy-1"]["start"], rows["queue/gate-2"]["start"]), (now - 100, None)) + + def test_the_queue_chain_follows_the_grant_order_of_queue_py(self): + now = time.time() + register, queue = self.plan_register(now) + entries = [(entry, entry["enqueued"]) for entry in queue["entries"]] + chain = tasks.queue_chain(entries, register, [], now) + self.assertEqual(chain, [("deploy-1", False), ("hot-4", True), ("gate-3", True), ("old-5", True), ("gate-2", True)]) + self.assertEqual(tasks.register_ranks(register, []), {"work/pinned": 0, "work/child": 1, "work/next": 2, "work/side": 3}) + waiting = [entry for entry in queue["entries"] if entry["status"] == "waiting"] + queue_py = load_queue() + for agents, first in (([], "gate-3"), (["Stage", "Docs"], "old-5")): + with self.subTest(agents=agents): + ranks = tasks.register_ranks(register, agents) + expected = [entry["id"] for entry in queue_py.ordered(waiting, ranks, {name: index for index, name in enumerate(agents)}, now)] + found = [job for job, waits in tasks.queue_chain(entries, register, agents, now) if waits] + self.assertEqual(found, expected) + self.assertEqual(found[:2], ["hot-4", first]) + + def test_a_bulk_business_value_is_stored_only_with_one_verified_assertion_over_the_exact_ids_and_values(self): + register = { + "work/a": {"status": "running", "estimates": {"Skills": {"value": 3, "complexity": 2}, "Docs": {"value": 5, "complexity": 2}}}, + "work/b": {"status": "queued", "estimates": {"Docs": {"value": 2, "complexity": 1}}}, + } + self.write_council({"rasci.json": register}) + before = (self.council / "rasci.json").read_bytes() + signer = self.pin() + batch = [valued("work/a", "21"), valued("work/b", "21")] + proof = self.signed(batch, signer) + good = self.guard(self.host) + for items, relayed, reason in ( + ([batch[0], valued("work/b", "34")], proof, "list every approved item"), + ([valued("work/b", "21"), valued("work/a", "34")], proof, "list every approved item"), + ([*batch, valued("work/c", "21")], proof, "not found"), + (batch, key(-7, "stranger").proof(proof["payload"], self.origin), "not signed"), + (batch, {**proof, "assertion": {**proof["assertion"], "signature": proof["assertion"]["signature"][::-1]}}, "not signed"), + (batch, None, "not signed"), + ): + with self.subTest(items=items, reason=reason): + status, _, body = self.post_json("/api/tasks", {"items": items, "proof": relayed}, good) + self.assertIn(status, (400, 404), body) + self.assertIn(reason, body.decode()) + self.assertEqual([job for job in self.snapshot()["jobs"] if job["kind"] == "task"], []) + status, _, body = self.post_json("/api/tasks", {"items": batch, "proof": proof}, good) + self.assertEqual(status, 202, body) + self.assertEqual(len(json.loads(body)["jobs"]), 2) + for items in (batch, batch[:1], batch[::-1]): + with self.subTest(replayed=items): + status, _, body = self.post_json("/api/tasks", {"items": items, "proof": proof}, good) + self.assertEqual(status, 400, body) + self.assertIn("already used", body.decode()) + self.assertEqual((self.council / "rasci.json").read_bytes(), before) + self.run_runner() + stored = json.loads((self.council / "rasci.json").read_text(encoding="utf-8")) + self.assertEqual({task: row["estimates"]["Operator"]["value"] for task, row in stored.items()}, {"work/a": 21, "work/b": 21}) + self.assertFalse(any("complexity" in row["estimates"]["Operator"] for row in stored.values())) + rows = {row["task"]: row for row in self.snapshot()["tasks"]} + self.assertEqual(rows["work/a"]["wsjf"], {"value": 21, "complexity": 2, "score": 10.5}) + self.assertEqual(rows["work/b"]["wsjf"], {"value": 21, "complexity": 1, "score": 21.0}) + self.assertEqual((rows["work/a"]["value"], rows["work/a"]["points"], rows["work/a"]["estimates"]["Operator"]), (21, 2, {"value": 21, "complexity": None})) + self.assertEqual(self.runner_jobs(), []) + tampered_fields = {"kind": "task", "task": "work/a", "argv": ["estimate", "work/a", "Operator", "--value", "34"], "command": "x", "directory": "", "sha256": "", "status": "queued", "proof": proof} + tampered = self.httpd.hub.jobs.add({**tampered_fields, "code": None, "output": "", "created_ts": time.time(), "started": None, "finished": None}) + replayed = self.httpd.hub.jobs.add({**tampered_fields, "argv": batch[0]["argv"], "code": None, "output": "", "created_ts": time.time(), "started": None, "finished": None}) + self.run_runner() + self.assertIn("does not list this item", self.httpd.hub.jobs.get(tampered["id"])["output"]) + self.assertIn("already used", self.httpd.hub.jobs.get(replayed["id"])["output"]) + self.assertEqual(json.loads((self.council / "rasci.json").read_text(encoding="utf-8")), stored) + + def test_estimates_go_out_only_on_an_explicit_request_in_story_points_mode_once_per_request(self): + self.write_council({"rasci.json": {"work/a": {"status": "queued", "roles": {"Skills": "RA"}}}}) + good = self.guard(self.host) + signer = self.pin() + self.snapshot() + self.index() + status, _, body = self.post_json("/api/board/estimates", {"proof": self.board_proof("estimates", signer)}, good) + self.assertEqual(status, 409, body) + self.assertEqual(self.post_json("/api/board/estimates", {}, self.client())[0], 403) + status, _, body = self.post_json("/api/settings", {**self.snapshot()["settings"], "estimation": "points", "proof": None}, good) + self.assertEqual((status, json.loads(body)["settings"]["estimation"]), (200, "points")) + self.snapshot() + self.index() + self.assertEqual(self.post_json("/api/board/estimates", {}, good)[0], 400) + self.assertEqual(self.post_json("/api/board/estimates", {"proof": None}, good)[0], 400) + self.assertEqual(self.scripts.calls, []) + proof = self.board_proof("estimates", signer) + status, _, body = self.post_json("/api/board/estimates", {"proof": proof}, good) + self.assertEqual(status, 200, body) + self.assertTrue(json.loads(body)["ok"]) + self.assertEqual(self.post_json("/api/board/estimates", {"proof": proof}, good)[0], 400) + self.assertEqual(self.scripts.calls, [(skill_scripts.ESTIMATE, ["request", "--session", "Operator"])]) + self.snapshot() + self.assertEqual(self.post_json("/api/settings", {**self.snapshot()["settings"], "estimation": "none", "proof": None}, good)[0], 200) + self.assertEqual(len(self.scripts.calls), 1) + self.assertEqual(settings.Settings(self.state / "settings.json").get()["estimation"], "none") + if __name__ == "__main__": unittest.main() diff --git a/tests/test_rasci.py b/tests/test_rasci.py index ca49fcb..37a2544 100644 --- a/tests/test_rasci.py +++ b/tests/test_rasci.py @@ -162,6 +162,53 @@ class TestRasci(unittest.TestCase): self._run("set", "work/side", "--base", "") self.assertFalse(any(line.startswith("base:") for line in self._out("get", "work/side"))) + def _after(self) -> dict[str, list[str]]: + rows = json.loads((self.root / "rasci.json").read_text(encoding="utf-8")) + return {task: row["after"] for task, row in rows.items() if "after" in row} + + def test_after_stores_and_drops_a_dependency_and_refuses_unknown_tasks_and_cycles(self): + for task in ("work/a", "work/b", "work/c"): + self._out("set", task) + self._out("set", "work/b", "--after", "work/a") + self._out("set", "work/c", "--after", "work/b", "--after", "work/a", "--after", "work/b") + self.assertEqual(self._after(), {"work/b": ["work/a"], "work/c": ["work/b", "work/a"]}) + self.assertIn("after: work/b", self._out("get", "work/c")) + before = (self.root / "rasci.json").read_bytes() + for args, reason in ( + (("set", "work/a", "--after", "work/c"), "closes a cycle"), + (("set", "work/a", "--after", "work/b", "--title", "kept out"), "closes a cycle"), + (("set", "work/a", "--after", "work/a"), "cannot follow itself"), + (("set", "work/a", "--after", "work/nope"), "no task of the register"), + (("set", "work/new", "--after", "work/nope"), "no task of the register"), + (("set", "work/a", "--after", "Bad Task"), "invalid task"), + ): + with self.subTest(args=args): + result = self._run(*args) + self.assertEqual(result.returncode, 2, result.stdout) + self.assertIn(reason, result.stderr) + self.assertEqual((self.root / "rasci.json").read_bytes(), before) + self._out("set", "work/c", "--drop-after", "work/b") + self.assertEqual(self._after(), {"work/b": ["work/a"], "work/c": ["work/a"]}) + self._out("set", "work/b", "--drop-after", "work/a") + self._out("set", "work/a", "--after", "work/b") + self.assertEqual(self._after(), {"work/a": ["work/b"], "work/c": ["work/a"]}) + + def test_the_operator_business_value_replaces_the_median_and_may_stand_alone(self): + self._run("estimate", "work/a", "One", "--value", "8", "--complexity", "2") + self._run("estimate", "work/a", "Two", "--value", "13", "--complexity", "3") + self._out("estimate", "work/a", "Operator", "--value", "34") + row = json.loads((self.root / "rasci.json").read_text(encoding="utf-8"))["work/a"] + self.assertNotIn("complexity", row["estimates"]["Operator"]) + self.assertEqual(self._out("wsjf")[2], "| 1 | work/a | - | 34 | 2.5 | 13.6 | One, Operator, Two | queued |") + self.assertIn("estimate Operator: business value 34, complexity -", self._out("get", "work/a")) + self._out("estimate", "work/a", "Operator", "--value", "21", "--complexity", "8") + self._out("estimate", "work/a", "Operator", "--value", "5") + row = json.loads((self.root / "rasci.json").read_text(encoding="utf-8"))["work/a"] + self.assertEqual((row["estimates"]["Operator"]["value"], row["estimates"]["Operator"]["complexity"]), (5, 8)) + self.assertEqual(self._out("wsjf")[2], "| 1 | work/a | - | 5 | 3 | 1.67 | One, Operator, Two | queued |") + self._out("estimate", "work/b", "Operator", "--value", "8") + self.assertEqual(self._out("wsjf")[3:], ["| 2 | work/b | - | - | - | - | Operator | queued |", "unestimated: work/b"]) + def test_done_tasks_show_only_with_all(self): self._run("set", "work/a", "--status", "done", "--end", "2026-11-01T12:00:00+00:00") self._run("role", "work/a", "Skills", "RA") @@ -257,6 +304,8 @@ class TestRasci(unittest.TestCase): ("set", "work/a", "--artifact", "no-kind"), ("estimate", "work/a", "One", "--value", "4", "--complexity", "2"), ("estimate", "work/a", "One", "--value", "8"), + ("estimate", "work/a", "Operator", "--complexity", "8"), + ("estimate", "work/a", "Operator", "--value", "4"), ): with self.subTest(args=args): self.assertEqual(self._run(*args).returncode, 2) From 2a77e4905f2f063d52c829fd66a3c15df851b876 Mon Sep 17 00:00:00 2001 From: Kevin Veen-Birkenbach Date: Mon, 9 Nov 2026 09:08:05 +0000 Subject: [PATCH 7/7] chore(lock): refresh the cavecrew and caveman-compress hashes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit make install pulled the current JuliusBrussee/caveman skills; their computed hashes in skills-lock.json follow. 🎯 Fix: 97 % 💥 Break: 1 % 💸 Cost: 100 % ⏱️ Time: – 🛡️ Security: 100 % 🏆 Score: 96 🚦 Gate: ✅ 90/5, cost and time <= 100, security 100 % Co-Authored-By: Claude Opus 5.5 --- skills-lock.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/skills-lock.json b/skills-lock.json index a2bab0f..a5e01e4 100644 --- a/skills-lock.json +++ b/skills-lock.json @@ -11,7 +11,7 @@ "source": "JuliusBrussee/caveman", "sourceType": "github", "skillPath": "skills/cavecrew/SKILL.md", - "computedHash": "2e122d819a812bef0e4958706f306e4346e78ecb5a4893997b99cbc19866f514" + "computedHash": "a6267b1713b9c5b25cc556273095ccf0eb182151c552a4c4c743e2fc14622c6a" }, "caveman": { "source": "JuliusBrussee/caveman", @@ -29,7 +29,7 @@ "source": "JuliusBrussee/caveman", "sourceType": "github", "skillPath": "skills/caveman-compress/SKILL.md", - "computedHash": "9c8d35882a93e387a584cc4efaacb74433d379a2bd02e3e6f6ad4f7c30ff55ed" + "computedHash": "6b1d0d5c658999ba47e17442ce9f92eb7236976d4536937e31cde49e38fa7dbe" }, "caveman-help": { "source": "JuliusBrussee/caveman",