Merge branch 'feature/agent-feedback-channel' into unify/skills-20261112-night

This commit is contained in:
Kevin Veen-Birkenbach committed 2026-11-13 08:53:04 +00:00
commit 018de9a7ff
14 files changed
+833 -95

No files matched your search

+47
View File
@@ -78,6 +78,53 @@ class TestHubConsole(HubCase):
self.assertEqual(console, output[-skill_scripts.OUTPUT_LIMIT :])
self.assertEqual(console, snapshot["jobs"][-1]["output"])
def test_only_a_done_or_failed_command_job_reports_the_command_and_directory_it_ran(self):
self.register("queued")
fields = {"task": "operator/greet", "command": COMMAND, "directory": str(self.outside), "sha256": DIGEST, "status": "running", "proof": None}
jobs = [
self.httpd.hub.jobs.add({**fields, **extra, "code": None, "output": "", "created_ts": time.time(), "started": time.time(), "finished": None, "dismissed": False})
for extra in ({}, {}, {}, {}, {}, {"kind": "gate", "argv": []})
]
reports = (
{"output": "token-42\n", "code": 0, "refused": False}, {"output": "token-42\n", "code": 3, "refused": False},
{"output": "", "code": -9, "refused": False}, {"output": "", "code": 130, "refused": False},
{"output": "token-42\n", "code": None, "refused": True}, {"output": "", "code": 1, "refused": False},
)
answers = [self.runner(f"/api/runner/{job['id']}/report", report) for job, report in zip(jobs, reports)]
self.assertEqual([(status, body["status"], len(body["runs"])) for status, body in answers], [
(200, "done", 1), (200, "failed", 1), (200, "failed", 1), (200, "failed", 1), (200, "refused", 0), (200, "failed", 0),
])
shown = ["greet", f"--command={COMMAND}", f"--dir={self.outside}"]
self.assertEqual(self.scripts.calls, [
(skill_scripts.OPERATOR_SCRIPT, ["ran", *shown]),
(skill_scripts.OPERATOR_SCRIPT, ["failed", *shown, "--why", "exit 3"]),
(skill_scripts.OPERATOR_SCRIPT, ["failed", *shown, "--why", "killed by signal 9"]),
(skill_scripts.OPERATOR_SCRIPT, ["failed", *shown, "--why", "exit 130"]),
])
self.assertNotIn("token-42", json.dumps(self.scripts.calls))
def test_an_older_installed_operator_without_ran_still_closes_the_row_through_done(self):
self.register("queued")
fields = {"task": "operator/greet", "command": COMMAND, "directory": str(self.outside), "sha256": DIGEST, "status": "running", "proof": None}
jobs = [
self.httpd.hub.jobs.add({**fields, "code": None, "output": "", "created_ts": time.time(), "started": time.time(), "finished": None, "dismissed": False})
for _ in range(2)
]
self.scripts.code = 2
done = self.runner(f"/api/runner/{jobs[0]['id']}/report", {"output": "", "code": 0, "refused": False})[1]
failed = self.runner(f"/api/runner/{jobs[1]['id']}/report", {"output": "", "code": 1, "refused": False})[1]
shown = ["greet", f"--command={COMMAND}", f"--dir={self.outside}"]
self.assertEqual(self.scripts.calls, [
(skill_scripts.OPERATOR_SCRIPT, ["ran", *shown]),
(skill_scripts.OPERATOR_SCRIPT, ["done", "greet"]),
(skill_scripts.OPERATOR_SCRIPT, ["failed", *shown, "--why", "exit 1"]),
])
self.assertEqual((len(done["runs"]), len(failed["runs"])), (2, 1))
self.scripts.code = 1
job = self.httpd.hub.jobs.add({**fields, "code": None, "output": "", "created_ts": time.time(), "started": time.time(), "finished": None, "dismissed": False})
self.runner(f"/api/runner/{job['id']}/report", {"output": "", "code": 0, "refused": False})
self.assertEqual(self.scripts.calls[-1], (skill_scripts.OPERATOR_SCRIPT, ["ran", *shown]))
def test_jobs_from_before_the_console_stay_out_of_the_inbox(self):
self.register("done")
fields = {"task": "operator/greet", "command": COMMAND, "directory": str(self.outside), "sha256": DIGEST, "status": "done", "proof": None}
+1 -1
View File
@@ -63,7 +63,7 @@ class TestHubExecutors(HubCase):
job = self.snapshot()["jobs"][-1]
self.assertEqual((job["status"], job["code"], job["output"]), ("done", 0, "hello\nworld\n"))
self.assertNotIn("proof", job)
self.assertEqual(self.scripts.calls[-1], (skill_scripts.OPERATOR_SCRIPT, ["done", "greet"]))
self.assertEqual(self.scripts.calls[-1], (skill_scripts.OPERATOR_SCRIPT, ["ran", "greet", f"--command={command}", f"--dir={self.outside}"]))
claim = {**self.client(), "Content-Type": "application/json"}
self.assertEqual(self.call("POST", f"/api/runner/{job['id']}/claim", b"{}", claim)[0], 409)
self.assertEqual(self.call("POST", f"/api/runner/{job['id']}/claim", b"{}", {**self.guard(self.host), "Content-Type": "application/json"})[0], 403)
+8
View File
@@ -64,6 +64,14 @@ class TestPresence(unittest.TestCase):
self.assertEqual(self.states({"later": record("later", "idle", FRESH, "Later")}, {}, "day", claims, news), {"later": "alive"})
self.assertEqual(self.states({"later": record("later", "idle", OLD, "Later")}, {}, "day", claims, news), {"later": "unreachable"})
def test_a_call_to_a_session_id_is_answered_by_its_receipt_under_a_new_name_and_flags_only_that_session(self):
call = NOW - 700
sessions = {"s1": record("s1", "idle", OLD, "Uno"), "sB": record("sB", "idle", OLD, "One")}
taken = [{"ts": call, "from": "Operator", "to": ["One"], "to_sessions": ["s1"], "class": "call"}]
receipt = {"ts": call + 2, "from": "Uno", "to": ["Operator"], "class": "receipt", "call": call}
self.assertEqual(self.states(sessions, {}, "day", [], [*taken, receipt]), {"s1": "alive", "sB": "alive"})
self.assertEqual(self.states(sessions, {}, "day", [], taken), {"s1": "unreachable", "sB": "alive"})
def test_a_record_without_running_true_is_dead(self):
for value in (False, None, "yes", 1):
with self.subTest(value=value):
+273
View File
@@ -125,6 +125,21 @@ class TestOperator(unittest.TestCase):
def _register(self) -> dict[str, dict]:
return json.loads((self.root / "rasci.json").read_text(encoding="utf-8"))
def _session(self, sid: str, name: str) -> None:
(self.home / ".claude" / "sessions" / f"{sid}.json").write_text(json.dumps({"sessionId": sid, "name": name}), encoding="utf-8")
def _as(self, sid: str | None, *args: str) -> subprocess.CompletedProcess:
env = {key: value for key, value in self.env.items() if key != "CLAUDE_CODE_SESSION_ID"}
return subprocess.run(
[sys.executable, str(OPERATOR), *args], capture_output=True, text=True,
env={**env, "CLAUDE_CODE_SESSION_ID": sid} if sid else env, cwd=self.tmp.name, check=False,
)
def _messages(self) -> list[tuple]:
news = self.root / "news.jsonl"
lines = news.read_text(encoding="utf-8").splitlines() if news.exists() else []
return [(row["class"], row["from"], row["to"], row["text"]) for row in map(json.loads, lines)]
def test_checks_close_rows_once_their_condition_holds(self):
for name in ("pipx", "git-sign-push"):
(self.bin / name).write_text("#!/bin/sh\n", encoding="utf-8")
@@ -542,6 +557,37 @@ class TestOperator(unittest.TestCase):
self.assertEqual(self._open(), ["operator/heavy"])
self.assertFalse((self.root / "queue-history.jsonl").exists())
def test_hold_queues_the_command_as_operator_without_the_claude_session(self):
self._queue_config({"operator": 0})
work = self.base / "work"
work.mkdir()
self._add("heavy", work, "touch heavy", "build", "manual")
fake = self.base / "queue.py"
fake.write_text(
"import json, os, sys\n"
"with open(sys.argv[0] + '.calls', 'a', encoding='utf-8') as calls:\n"
" calls.write(json.dumps([sys.argv[1:3], os.environ.get('CLAUDE_CODE_SESSION_ID')]) + '\\n')\n"
"sys.exit(75 if sys.argv[1] == 'hold' else 0)\n",
encoding="utf-8",
)
wrapper = (
"import importlib.util, sys\n"
"spec = importlib.util.spec_from_file_location('kvb_operator', sys.argv[1])\n"
"operator = importlib.util.module_from_spec(spec)\n"
"spec.loader.exec_module(operator)\n"
"operator.QUEUE = operator.Path(sys.argv[2])\n"
"sys.argv = [sys.argv[1], 'run']\n"
"sys.exit(operator.main())\n"
)
result = subprocess.run(
[sys.executable, "-c", wrapper, str(OPERATOR), str(fake)], input="h\n", capture_output=True, text=True,
env={**self.env, "SHELL": "/bin/sh"}, cwd=self.tmp.name, check=False,
)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertIn("not run operator/heavy", result.stdout)
calls = [json.loads(line) for line in (self.base / "queue.py.calls").read_text(encoding="utf-8").splitlines()]
self.assertEqual(calls, [[["list"], "s1"], [["hold", "--kind"], None]])
def test_run_offers_no_hold_while_the_config_lacks_the_operator_kind(self):
self._queue_config({"test": 0})
work = self.base / "work"
@@ -592,6 +638,233 @@ class TestOperator(unittest.TestCase):
self.assertTrue((work / "heavy").exists())
self.assertFalse((self.base / "heavy").exists() or (work / "other").exists())
def test_a_done_run_reaches_the_renamed_adder_by_its_stored_name_and_session_through_its_feedback_channel(self):
work = self.base / "work"
work.mkdir()
self._add("go", work, "true", "r", "manual")
self._add("later", work, "true", "r", "manual")
self.assertEqual(self._register()["operator/go"]["sessions"], {"One": "s1"})
self._session("s1", "Uno")
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
chosen = subprocess.run([sys.executable, str(radio), "feedback", "set", "call"], capture_output=True, text=True, env=self.env, check=False)
self.assertEqual(chosen.returncode, 0, chosen.stderr)
listener = self.root / "radio-listen" / "s1.pid"
listener.parent.mkdir()
listener.write_text(str(os.getpid()), encoding="utf-8")
result = self._feed("y\ns\n")
self.assertEqual(result.returncode, 0, result.stderr)
self.assertIn("done operator/go; the result went to One as a call", result.stdout)
self.assertIn("skipped operator/later", result.stdout)
self.assertEqual(self._messages(), [("call", "Operator", ["One"], "Operator ran operator/go: done")])
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
seen = subprocess.run([sys.executable, str(radio), "show"], capture_output=True, text=True, env=self.env, check=False)
self.assertEqual([line.split(" ", 3)[3] for line in seen.stdout.splitlines()], ["Operator to One: Operator ran operator/go: done"], seen.stderr)
def test_an_older_row_without_a_session_reaches_its_party_name_and_an_open_check_is_reported(self):
stale = self.base / "stale"
stale.write_text("x", encoding="utf-8")
self._add("old", self.base, "true", "r", f"absent:{stale}")
register = self._register()
register["operator/old"].pop("sessions")
(self.root / "rasci.json").write_text(json.dumps(register), encoding="utf-8")
self._session("s1", "Uno")
result = self._feed("y\n")
self.assertEqual(result.returncode, 0, result.stderr)
pending = f"absent:{stale} does not pass yet; the row stays open"
self.assertIn(f"ran operator/old, but {pending}; the result went to One as a post", result.stdout)
self.assertEqual(self._messages(), [("post", "Operator", ["One"], f"Operator ran operator/old; exit 0, but {pending}")])
self.assertEqual(self._open(), ["operator/old"])
def test_list_and_done_tell_every_holder_but_the_caller(self):
self._session("s2", "Two")
stale = self.base / "stale"
stale.write_text("x", encoding="utf-8")
for slug in ("mine", "theirs"):
self._add(slug, self.base, "true", "r", f"absent:{stale}")
self._add("manual", self.base, "true", "r", "manual")
self._add("hub", self.base, "true", "r", "manual")
self._add("self", self.base, "true", "r", "manual")
stale.unlink()
self.assertEqual(self._out("list", "--json")[0], "[")
self._add("mine", self.base, "true", "r", f"absent:{self.base / 'gone'}")
self.assertEqual(self._as(None, "list", "--session", "s1").stderr, "")
self.assertEqual(self._messages(), [])
self._add("theirs", self.base, "true", "r", f"absent:{self.base / 'gone'}")
listed = self._as("s2", "list", "--json")
self.assertEqual((listed.returncode, listed.stderr), (0, "operator: operator/theirs done; the result went to One as a post\n"))
self.assertEqual([row["task"] for row in json.loads(listed.stdout)], ["operator/manual", "operator/hub", "operator/self"])
self.assertEqual(self._as("s2", "done", "manual").stdout, "done operator/manual; the result went to One as a post\n")
self.assertEqual(self._as("s2", "done", "manual").stdout, "done operator/manual\n")
self.assertEqual(self._as(None, "done", "hub").returncode, 0)
self.assertEqual(self._out("done", "self"), ["done operator/self"])
self.assertEqual(self._messages(), [
("post", "Operator", ["One"], f"operator/theirs done: its check absent:{self.base / 'gone'} passes"),
("post", "Operator", ["One"], "operator/manual marked done by Two"),
("post", "Operator", ["One"], "operator/hub marked done by Operator"),
])
self._add("flag", self.base, "true", "r", "manual")
self.assertEqual(self._as(None, "done", "flag", "--session", "s2").returncode, 0)
self.assertEqual(self._messages()[-1][-1], "operator/flag marked done by Two")
self._add("late", self.base, "true", "r", f"absent:{self.base / 'gone'}")
victim = self.base / "victim"
victim.write_text("keep", encoding="utf-8")
(self.root / "news.lock").unlink()
(self.root / "news.lock").symlink_to(victim)
unsent = self._as("s2", "list")
self.assertEqual(unsent.returncode, 0, unsent.stderr)
self.assertRegex(unsent.stderr, r"^operator: operator/late done; the message to One failed: .+\n$")
self.assertEqual(victim.read_text(encoding="utf-8"), "keep")
def test_failed_stops_only_the_row_the_hub_ran_and_tells_the_adder(self):
work = self.base / "work"
work.mkdir()
self._add("break", work, "false", "r", "manual")
self._add("moved", work, "true", "r", "manual")
shown = ("--command", "false", "--dir", str(work))
result = self._as(None, "failed", "break", "--why", "exit 3", *shown)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stdout, "failed operator/break: exit 3; removed from the queue, the error went to One as a post\n")
for args in (("--command", "true", "--dir", str(self.base)), ("--command", "echo evil", "--dir", str(work))):
with self.subTest(args=args):
stale = self._as(None, "failed", "moved", "--why", "exit 1", *args)
self.assertIn("it changed or closed meanwhile and stays as it is", stale.stdout)
register = self._register()
self.assertEqual((register["operator/break"]["status"], register["operator/break"]["failed"]), ("stopped", {"why": "exit 3", "output": []}))
self.assertEqual((register["operator/moved"]["status"], "failed" in register["operator/moved"]), ("queued", False))
self.assertEqual(self._messages(), [("post", "Operator", ["One"], (
f"Operator ran operator/break (false in {work}); it failed with exit 3 and left the operator queue. "
"The operator shared no stderr lines. Find the cause, then queue the corrected command with operator.py add break, or drop the step."
))])
again = self._as(None, "failed", "break", "--why", "exit 3", *shown)
self.assertIn("it changed or closed meanwhile and stays as it is", again.stdout)
self.assertEqual(len(self._messages()), 1)
for args in (("failed", "missing", "--why", "exit 1", *shown), ("failed", "break", "--why", " ", *shown), ("failed", "break", "--why", "exit 1")):
with self.subTest(args=args):
self.assertEqual(self._as(None, *args).returncode, 2)
def test_ran_in_the_hub_container_closes_whatever_the_check_and_reaches_the_pinned_session_and_the_stored_name(self):
tool = self.bin / "kvb-host-only-tool"
tool.write_text("#!/bin/sh\n", encoding="utf-8")
tool.chmod(0o755)
self._add("go", self.base, "true", "r", "manual")
self._add("inst", self.base, "true", "r", "binary:kvb-host-only-tool")
self._add("other", self.base, "true", "r", "manual")
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
chosen = subprocess.run([sys.executable, str(radio), "feedback", "set", "call"], capture_output=True, text=True, env=self.env, check=False)
self.assertEqual(chosen.returncode, 0, chosen.stderr)
self._session("s1", "Uno")
hub_home = self.base / "hub-home"
hub_home.mkdir()
hub = {"PATH": "/usr/bin:/bin", "HOME": str(hub_home), "AGENTS_COUNCIL_ROOT": str(self.root)}
def ran(*args: str) -> str:
result = subprocess.run([sys.executable, str(OPERATOR), "ran", *args], capture_output=True, text=True, env=hub, cwd=self.tmp.name, check=False)
self.assertEqual(result.returncode, 0, result.stderr)
return result.stdout
shown = ("--command", "true", "--dir", str(self.base))
wake = "wake: SendMessage to One (session s1)"
self.assertEqual(ran("go", *shown), f"done operator/go; the result went to One queued as a call; {wake}\n")
self.assertEqual(ran("inst", *shown), f"done operator/inst; the result went to One queued as a call; {wake}\n")
self.assertEqual(ran("other", "--command", "true", "--dir", str(hub_home)), "ran operator/other; it changed or closed meanwhile and stays as it is\n")
self.assertEqual(self._open(), ["operator/other"])
self.assertEqual(self._messages(), [
("call", "Operator", ["One"], "Operator ran operator/go: done"),
("call", "Operator", ["One"], "Operator ran operator/inst: done"),
])
rows = [json.loads(line) for line in (self.root / "news.jsonl").read_text(encoding="utf-8").splitlines()]
self.assertEqual([row["to_sessions"] for row in rows], [["s1"], ["s1"]])
self._session("s2", "One")
self._session("s3", "Uno")
expected = ["Operator to One: Operator ran operator/go: done", "Operator to One: Operator ran operator/inst: done"]
for sid, seen in (("s1", expected), ("s2", expected), ("s3", [])):
with self.subTest(sid=sid):
read = subprocess.run([sys.executable, str(radio), "show"], capture_output=True, text=True, env={**self.env, "CLAUDE_CODE_SESSION_ID": sid}, check=False)
self.assertEqual([line.split(" ", 3)[3] for line in read.stdout.splitlines()], seen, read.stderr)
view = (
"import json, sys\n"
"sys.path.insert(0, sys.argv[1])\n"
"from kvb_orchestrator.council import radio_rows\n"
"rows = [json.loads(line) for line in open(sys.argv[2], encoding='utf-8')]\n"
"print(json.dumps([row['to'] for row in radio_rows(rows, 0, 1e12)]))\n"
)
hub_view = subprocess.run(
[sys.executable, "-c", view, str(REPO_ROOT / "orchestrator"), str(self.root / "news.jsonl")],
capture_output=True, text=True, env={**hub, "PYTHONDONTWRITEBYTECODE": "1"}, check=False,
)
self.assertEqual(json.loads(hub_view.stdout or "null"), [["One"], ["One"]], hub_view.stderr)
for args in (("ran", "missing", *shown), ("ran", "go", "--command", "true")):
with self.subTest(args=args):
self.assertEqual(self._as(None, *args).returncode, 2)
def test_done_leaves_out_the_caller_by_session_id_and_by_name_each_on_its_own(self):
self._add("by-sid", self.base, "true", "r", "manual")
self._add("by-name", self.base, "true", "r", "manual")
register = self._register()
register["operator/by-name"].pop("sessions")
(self.root / "rasci.json").write_text(json.dumps(register), encoding="utf-8")
hub_home = self.base / "hub-home"
hub_home.mkdir()
hub = {"PATH": "/usr/bin:/bin", "HOME": str(hub_home), "AGENTS_COUNCIL_ROOT": str(self.root)}
by_sid = subprocess.run([sys.executable, str(OPERATOR), "done", "by-sid", "--session", "s1"], capture_output=True, text=True, env=hub, check=False)
self.assertEqual((by_sid.returncode, by_sid.stdout), (0, "done operator/by-sid\n"), by_sid.stderr)
self.assertEqual(self._out("done", "by-name"), ["done operator/by-name"])
self.assertEqual(self._messages(), [])
def test_done_by_the_successor_holding_the_stored_name_reaches_the_renamed_adder_by_its_session_only(self):
self._add("go", self.base, "true", "r", "manual")
self._session("s1", "Uno")
self._session("s2", "One")
done = self._as("s2", "done", "go")
self.assertEqual((done.returncode, done.stdout), (0, "done operator/go; the result went to s1 as a post\n"), done.stderr)
self.assertEqual(self._messages(), [("post", "Operator", ["s1"], "operator/go marked done by One")])
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
for sid, seen in (("s1", 1), ("s2", 0)):
with self.subTest(sid=sid):
read = subprocess.run([sys.executable, str(radio), "show"], capture_output=True, text=True, env={**self.env, "CLAUDE_CODE_SESSION_ID": sid}, check=False)
self.assertEqual(len(read.stdout.splitlines()), seen, read.stderr)
self._add("own", self.base, "true", "r", "manual")
self.assertEqual(self._as("s1", "done", "own").stdout, "done operator/own\n")
self.assertEqual(len(self._messages()), 1)
def test_ran_closes_a_stopped_or_running_row_the_hub_ran_and_tells_the_adder(self):
for slug in ("stopped", "running", "done"):
self._add(slug, self.base, "true", "r", "manual")
register = self._register()
for slug in ("stopped", "running", "done"):
register[f"operator/{slug}"]["status"] = slug
register["operator/stopped"].update(failed={"why": "exit 1", "output": []}, cancelled="wrong repo")
(self.root / "rasci.json").write_text(json.dumps(register), encoding="utf-8")
shown = ("--command", "true", "--dir", str(self.base))
for slug in ("stopped", "running"):
with self.subTest(slug=slug):
self.assertEqual(self._as(None, "ran", slug, *shown).stdout, f"done operator/{slug}; the result went to One as a post\n")
entry = self._register()[f"operator/{slug}"]
self.assertEqual((entry["status"], "failed" in entry, "cancelled" in entry), ("done", False, False))
self.assertEqual(self._as(None, "ran", "done", *shown).stdout, "ran operator/done; it changed or closed meanwhile and stays as it is\n")
self.assertEqual([message[3] for message in self._messages()], ["Operator ran operator/stopped: done", "Operator ran operator/running: done"])
def test_done_drops_the_stale_failure_of_a_stopped_row_like_ran(self):
self._add("go", self.base, "false", "r", "manual")
self.assertEqual(self._as(None, "failed", "go", "--why", "exit 1", "--command", "false", "--dir", str(self.base)).returncode, 0)
register = self._register()
register["operator/go"]["cancelled"] = "wrong repo"
(self.root / "rasci.json").write_text(json.dumps(register), encoding="utf-8")
self.assertEqual(self._out("done", "go"), ["done operator/go"])
entry = self._register()["operator/go"]
self.assertEqual((entry["status"], "failed" in entry, "cancelled" in entry), ("done", False, False))
def test_feedback_for_an_ended_adder_reaches_the_session_now_holding_its_name(self):
self._add("go", self.base, "true", "r", "manual")
sessions = self.home / ".claude" / "sessions"
(sessions / "s1.json").unlink()
self._session("s2", "One")
self.assertEqual(self._as(None, "failed", "go", "--why", "exit 1", "--command", "true", "--dir", str(self.base)).returncode, 0)
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
seen = subprocess.run([sys.executable, str(radio), "show"], capture_output=True, text=True, env={**self.env, "CLAUDE_CODE_SESSION_ID": "s2"}, check=False)
self.assertEqual(len(seen.stdout.splitlines()), 1, seen.stderr)
self.assertIn("Operator to One: Operator ran operator/go (true in", seen.stdout)
def test_run_needs_shell(self):
self._add("x", self.base, "true", "r", "manual")
result = subprocess.run(
+4 -1
View File
@@ -13,7 +13,10 @@ from pathlib import Path
REPO_ROOT = Path(__file__).resolve().parents[1]
SCRIPT = REPO_ROOT / "scripts" / "orchestrator.sh"
HOST_SCRIPTS = ("kvb-org-organize/scripts/council.py", "kvb-org-organize/scripts/nofollow.py", "kvb-org-rasci/scripts/rasci.py")
HOST_SCRIPTS = (
"kvb-org-organize/scripts/council.py", "kvb-org-organize/scripts/nofollow.py", "kvb-org-rasci/scripts/rasci.py",
"kvb-org-operator/scripts/operator.py", "kvb-org-radio/scripts/radio.py",
)
OLD = "kvb-hub"
NEW = "kvb-orchestrator"
STUB = r'''#!/usr/bin/env python3
+114
View File
@@ -649,6 +649,120 @@ class TestRadio(unittest.TestCase):
self.assertEqual(quiet.returncode, 0)
self.assertIn("council hooks stay off", quiet.stdout)
def test_feedback_is_a_post_unless_the_session_set_call(self):
self.assertEqual(self._send("s2", "feedback", "show"), ["post"])
self.assertEqual(self._send("s2", "feedback", "set", "call"), ["feedback: call"])
self.assertEqual(self._send("x9", "feedback", "set", "post"), ["feedback: post"])
self.assertEqual((self._send("s2", "feedback", "show"), self._send("s3", "feedback", "show")), (["call"], ["post"]))
self.assertEqual(self._send(None, "feedback", "show", "--session", "s2"), ["call"])
self.assertEqual(json.loads((self.root / "feedback.json").read_text(encoding="utf-8")), {"s2": "call", "x9": "post"})
for args in (("feedback", "set", "radio"), ("feedback", "send", "text"), ("feedback", "send", " ", "--to", "Two"), ("feedback",)):
with self.subTest(args=args):
self.assertEqual(self._cli("s1", *args).returncode, 2)
def test_a_pinned_row_reaches_its_session_under_any_name_and_whoever_holds_its_stored_name(self):
self._send("s2", "feedback", "set", "call")
hub_home = self.home.parent / "hub-home"
hub_home.mkdir()
hub = {**self._env(None), "HOME": str(hub_home)}
def send(*args: str) -> subprocess.CompletedProcess:
return subprocess.run(
[sys.executable, str(RADIO), "feedback", "send", "ran x", *args, "--session", "Operator"],
capture_output=True, text=True, env=hub, check=False, timeout=30,
)
self.assertEqual(send("--to", "Two", "--sid", "s2").stdout.splitlines(), ["sent call to Two", "wake: SendMessage to Two (session s2)"])
self.assertEqual(send("--to", "Three", "--sid", "s3").stdout.splitlines(), ["sent post to Three"])
self.assertEqual(send("--to", "Two", "--to", "Three", "--sid", "s2").returncode, 2)
self.assertEqual([(row["class"], row["to"], row["to_sessions"]) for row in self._rows()], [("call", ["Two"], ["s2"]), ("post", ["Three"], ["s3"])])
sessions = self.home / ".claude" / "sessions"
for sid, name in (("s2", "Deux"), ("s3", "Two"), ("s4", "Deux")):
(sessions / f"{sid}.json").write_text(json.dumps({"sessionId": sid, "name": name}), encoding="utf-8")
self.assertEqual(self._send(None, "show", "--all")[0].split(" ", 3)[3], "Operator to Two: ran x")
self.assertEqual(self._prompt("s2"), ["CALL Operator to Two: ran x"])
self.assertEqual(self._prompt("s3"), ["CALL Operator to Two: ran x"])
self.assertEqual(self._mailbox("s3"), (2, ["POST Operator to Three: ran x"]))
self.assertEqual((self._prompt("s4"), self._mailbox("s4")), ([], (0, [])))
self.assertEqual((self._prompt("s1"), self._mailbox("s1")), ([], (0, [])))
self._send("s1", "post", "plain", "--to", "Two")
self.assertNotIn("to_sessions", self._rows()[-1])
def test_a_row_for_an_ended_adder_reaches_whoever_holds_its_stored_name_on_the_adders_channel(self):
sessions = self.home / ".claude" / "sessions"
self._send(None, "feedback", "set", "call", "--session", "s2")
self._send(None, "feedback", "set", "post", "--session", "s3")
(sessions / "s2.json").unlink()
(sessions / "s3.json").write_text(json.dumps({"sessionId": "s3", "name": "Two"}), encoding="utf-8")
self.assertEqual(self._send("s1", "feedback", "send", "ran x", "--to", "Two", "--sid", "s2"), ["sent call to Two", "wake: SendMessage to Two (session s2)"])
self._pidfile("s3").parent.mkdir(parents=True)
self._pidfile("s3").write_text(str(os.getpid()), encoding="utf-8")
self.assertEqual(self._send("s1", "feedback", "send", "ran y", "--to", "Two", "--sid", "s2"), ["sent call to Two"])
self.assertEqual(self._prompt("s3"), ["CALL One to Two: ran x", "CALL One to Two: ran y"])
self.assertEqual(self._prompt("s1"), [])
def test_a_row_pinned_to_a_codex_session_reaches_it_by_its_id(self):
self._send(None, "feedback", "set", "call", "--session", "codex-1")
self.assertEqual(
self._send("s1", "feedback", "send", "ran x", "--to", "Codex", "--sid", "codex-1"),
["sent call to Codex", "wake: SendMessage to Codex (session codex-1)"],
)
self.assertEqual([strip(line) for line in self._send(None, "show", "--session", "codex-1")], ["CALL One to Codex: ran x"])
self.assertEqual(self._send(None, "show", "--session", "codex-2"), [])
def test_a_row_whose_session_ids_are_no_strings_falls_back_to_its_names(self):
self.root.mkdir(mode=0o700)
rows = [
{"from": "X", "to": ["Two"], "to_sessions": sessions, "text": f"t{n}", "class": "post", "v": 2, "ts": time.time() - 10 + n}
for n, sessions in enumerate(([1], [["x"]], None))
]
(self.root / "news.jsonl").write_text("".join(json.dumps(row) + "\n" for row in rows), encoding="utf-8")
(self.root / "news.jsonl").chmod(0o600)
self.assertEqual(self._mailbox("s2"), (2, ["POST X to Two: t0", "POST X to Two: t1", "POST X to Two: t2"]))
self.assertEqual(self._mailbox("s3"), (0, []))
def test_a_row_reaches_its_session_and_its_name_when_no_session_is_known_as_live(self):
self._send("s1", "feedback", "send", "ran x", "--to", "Two", "--sid", "s2")
hub_home = self.home.parent / "hub-home"
hub_home.mkdir()
def shown(session: str) -> list[str]:
done = subprocess.run(
[sys.executable, str(RADIO), "show", "--session", session], capture_output=True, text=True,
env={**self._env(None), "HOME": str(hub_home)}, check=False, timeout=30,
)
self.assertEqual(done.returncode, 0, done.stderr)
return [strip(line) for line in done.stdout.splitlines()]
self.assertEqual((shown("s2"), shown("Two"), shown("s3")), (["POST One to Two: ran x"], ["POST One to Two: ran x"], []))
def test_a_pinned_call_wakes_nobody_while_a_listener_of_its_session_or_its_name_runs(self):
self._pidfile("s2").parent.mkdir(parents=True)
self._pidfile("s2").write_text(str(os.getpid()), encoding="utf-8")
(self.home / ".claude" / "sessions" / "s9.json").write_text(json.dumps({"sessionId": "s9", "name": "Nine"}), encoding="utf-8")
self._send(None, "feedback", "set", "call", "--session", "s9")
self._send("s2", "feedback", "set", "call")
hub_home = self.home.parent / "hub-home"
hub_home.mkdir()
sent = subprocess.run(
[sys.executable, str(RADIO), "feedback", "send", "ran x", "--to", "Two", "--sid", "s2", "--session", "Operator"],
capture_output=True, text=True, env={**self._env(None), "HOME": str(hub_home)}, check=False, timeout=30,
)
self.assertEqual(sent.stdout.splitlines(), ["sent call to Two"], sent.stderr)
self.assertEqual(self._send("s1", "feedback", "send", "ran y", "--to", "Two", "--sid", "s9"), ["sent call to Two"])
self.assertEqual(self._send("s1", "feedback", "send", "ran z", "--to", "Nine", "--sid", "s9"), ["sent call to Nine", "wake: SendMessage to Nine (session s9)"])
def test_feedback_send_without_a_session_takes_the_channel_the_name_set(self):
self._send("s2", "feedback", "set", "call")
self._send(None, "feedback", "set", "call", "--session", "codex-1")
self.assertEqual(
self._send("s1", "feedback", "send", "ran x", "--to", "Two", "--to", "Gone", "--to", "codex-1"),
["sent post to Two", "sent post to Gone", "sent call to codex-1", "wake: SendMessage to codex-1"],
)
self.assertEqual([strip(line) for line in self._send(None, "show", "--session", "codex-1")], ["CALL One to codex-1: ran x"])
self.assertEqual(self._mailbox("s2"), (2, ["POST One to Two: ran x"]))
self.assertNotIn("to_sessions", self._rows()[-1])
if __name__ == "__main__":
unittest.main()