feat(operator): report each operator row outcome back to the agent that queued it

operator.py stores the adding session's name and id with the row. Done,
cancel and failure go to that stored name and pinned session id, never
re-resolved: a radio post by default, a call when that session picked it
with radio.py feedback set call. The caller's own parts are dropped. The
hub counts unanswered calls per session id.

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

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

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Kevin Veen-BirkenbachandClaude Opus 5.5 committed 2026-11-13 06:42:51 +00:00
1 parent 3418738993
commit 7d70e07b4c
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()