feat(kvb-org-operator): call the initiating agent back on every row close

Operator order 2026-11-13: once the operator ran a command, the agent that queued it must hear it directly, without the operator relaying it. Every row close now sends one radio call to the stored initiator (party name plus the session id add pinned; legacy rows by the A name): run and hub ran (done, exit 0), check still open, the check-pass sweep of list and run, done, cancel, failure and hub failed. The call names row, outcome and exit code and never carries command output; shared stderr stays in failed.output of the register. radio.py send takes --sid for a call to exactly one address. Accepted MEDUSA false positives: CGS-SCAN-029 and CGS-SCAN-030 at operator.py:930, which runs the row command only after the operator's per-row answer.

🎯 Fix: 93 %
💥 Break: 4 %
💸 Cost: 105 %
⏱️ Time: 100 %
🛡️ Security: 100 %
🏆 Score: 85
🚦 Gate: ⚠️ cost 105 % > 100: ask the operator before the commit

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 16:50:01 +00:00
1 parent ca9cd96442
commit 7cb2616528
7 files changed
+242 -102

No files matched your search

+5 -4
View File
@@ -52,10 +52,11 @@ order (commits, pushes, installs, binaries, removals, manual steps), one
operator reports a `manual` step done, run `operator.py done <slug>`. operator reports a `manual` step done, run `operator.py done <slug>`.
`run` is the operator's script, never an agent's; `run.md` next to this `run` is the operator's script, never an agent's; `run.md` next to this
file says what it shows and asks. Operator reports each outcome of your row file says what it shows and asks. Operator calls you once per outcome of
through your `radio.py feedback` channel. A cancel or failure took the row your row (run, check, done): slug, outcome, exit code, never output. A
out of the queue: fix the cause it names, then re-add the corrected command cancel or failure took the row out of the queue: fix the
under the same slug or drop the step; never re-add it unchanged. cause it names, then re-add the corrected command under the same slug or
drop the step; never re-add it unchanged.
Never poll peers; a sweep runs only when the operator asks for one, as Never poll peers; a sweep runs only when the operator asks for one, as
`sweep.md` next to this file says. `sweep.md` next to this file says.
+16 -10
View File
@@ -6,20 +6,26 @@ removal deletes, the repository state), and runs the command only on `y`;
`d` shows the full diff, `s` skips, `c` cancels with a reason the operator `d` shows the full diff, `s` skips, `c` cancels with a reason the operator
must give (empty goes back), `q` stops. Nothing answers for the operator. must give (empty goes back), `q` stops. Nothing answers for the operator.
Every message goes to each agent holding A through its `radio.py feedback` Every outcome below goes to each agent holding A as a radio call to the
channel. name and session `add` stored (a row without one: the name), whatever its
`radio.py feedback` channel; the call names slug, outcome and exit, never
command output. A row that closes outside `run` calls the same way, once:
its check passing in the sweep of `list`, `run` or `granted` ("... done:
check passed (<check>)"), or `done` ("... marked done by <name>").
- **Done**: exit 0 sets the row `done` once its check passes and sends - **Done**: exit 0 sets the row `done` once its check passes and sends
"Operator ran operator/<slug>: done"; a check not passing yet keeps the "Operator ran operator/<slug>: done, exit 0"; a check not passing yet
row open and says so. keeps the row open and says so.
- **Cancel**: sets the row `stopped` with the reason under `cancelled` and - **Cancel**: sets the row `stopped` with the reason under `cancelled` and
sends "Operator cancelled operator/<slug> (...): <reason>". That agent sends "Operator cancelled operator/<slug> (...): <reason>". That agent
treats it as the operator's rejection of exactly that step. treats it as the operator's rejection of exactly that step.
- **Failure**: a command that exits non-zero or cannot start leaves the - **Failure**: a command that exits non-zero or cannot start leaves the
queue the same way. The row is set `stopped` with the exit under queue the same way. The row is set `stopped` with the exit, or `no
`failed` and sent with the request to queue the corrected command. start` and the errno name, under `failed` and sent with the request to
queue the corrected command.
`run` first asks whether to share the last 20 stderr lines: only `y` `run` first asks whether to share the last 20 stderr lines: only `y`
adds them, since stderr can hold a credential. stores them under the row's `failed.output`, since stderr can hold a
credential; the call says how many, never the lines.
The stderr passes through to the terminal while the command runs; stdin The stderr passes through to the terminal while the command runs; stdin
and stdout stay the terminal's, so prompts keep working. and stdout stay the terminal's, so prompts keep working.
- **Interrupt**: exit 130 or a signal is the operator's own abort; the row - **Interrupt**: exit 130 or a signal is the operator's own abort; the row
@@ -30,7 +36,7 @@ channel.
`add` under the same slug reopens the row and clears `cancelled` and `add` under the same slug reopens the row and clears `cancelled` and
`failed`. `failed`.
The hub's runner reports through `ran` and `failed`: exit 0 closes the row The hub's runner reports through `ran` and `failed`, as the same calls:
from any status but done, whatever its check; exit 130 and signals count exit 0 closes the row from any status but done, whatever its check; exit
as failures. Any agent of the same user can forge `ran`, `failed` or 130 and signals count as failures. Any agent of the same user can forge `ran`, `failed` or
`done`: the register and the radio are writable by every agent already. `done`: the register and the radio are writable by every agent already.
+35 -40
View File
@@ -54,8 +54,9 @@ Args:
that exits non-zero or cannot start leaves the that exits non-zero or cannot start leaves the
queue the same way: the row is set stopped with the exit under queue the same way: the row is set stopped with the exit under
`failed`, sent as a message with the request to queue `failed`, sent as a message with the request to queue
the corrected command under the same slug; the stderr lines join it the corrected command under the same slug; the stderr lines go under
only when the operator answers y to sharing them. Exit 130 or a `failed.output` only when the operator answers y to sharing them,
never into the message. Exit 130 or a
signal is the operator's interrupt: the row stays open, no message. signal is the operator's interrupt: the row stays open, no message.
A command A command
the kvb-org-organize watch config calls heavy also shows the memory the kvb-org-organize watch config calls heavy also shows the memory
@@ -96,18 +97,24 @@ Output:
each holding `cd <dir>` and the command, and a last block with the each holding `cd <dir>` and the command, and a last block with the
`run` invocation. `operator: nothing open` when none is. --json `run` invocation. `operator: nothing open` when none is. --json
prints the same rows as a JSON list. prints the same rows as a JSON list.
message: one line from Operator through `radio.py feedback send` to message: one line from Operator to every agent holding A but Operator
every agent holding A but Operator and the caller, by the party name and the caller, by the party name and the session id `add` stored
and the session id `add` stored (--sid), never resolved again; a (--sid), never resolved again, on a row without one by the party
party name the caller holds now is left out and the id alone, as name alone; a party name the caller holds now is left out and the
the --to label too, carries the message: id alone, as the --to label too, carries the message. Every message
run and ran done: `Operator ran <row>: done` is a `radio.py send call`, whatever the agent's feedback channel,
and never carries command output; a row that closes is told once,
by whichever step closed it:
run and ran done: `Operator ran <row>: done, exit 0`
run, check open: `Operator ran <row>; exit 0, but <check> does run, check open: `Operator ran <row>; exit 0, but <check> does
not pass yet; the row stays open` not pass yet; the row stays open`
list: `<row> done: its check <check> passes`, and on stderr the check sweep of list, run and granted: `<row> done: check
`operator: <row> done; <how it went>` passed (<check>)`, and on stderr `operator: <row> done; <how
it went>`
done: `<row> marked done by <caller name>` done: `<row> marked done by <caller name>`
cancel, failure and failed: the reason or the error. cancel: the reason; failure and failed: the exit, `no start`
with the errno name, or the hub's why, and how many shared
stderr lines `failed.output` holds.
A row changed or closed since it was shown gets no message. A row changed or closed since it was shown gets no message.
Exit codes: Exit codes:
@@ -126,6 +133,7 @@ sys.path.sort(key=lambda entry: os.path.realpath(entry) == os.path.dirname(os.pa
import argparse import argparse
import contextlib import contextlib
import errno
import hashlib import hashlib
import importlib.util import importlib.util
import json import json
@@ -154,7 +162,6 @@ GRANT_SECONDS = 600
FAILED_LINES = 20 FAILED_LINES = 20
FAILED_BYTES = 65536 FAILED_BYTES = 65536
LINE_CHARS = 300 LINE_CHARS = 300
POSTED_CHARS = 500
DRAIN_SECONDS = 0.2 DRAIN_SECONDS = 0.2
INTERRUPTED = 130 INTERRUPTED = 130
SUDO = re.compile(r"\bsudo\b") SUDO = re.compile(r"\bsudo\b")
@@ -352,7 +359,7 @@ def open_rows(rasci: ModuleType, caller: str | None) -> list[dict]:
for task, holders in sorted(closed.items()): for task, holders in sorted(closed.items()):
agents = addressees(holders, caller) agents = addressees(holders, caller)
if agents: if agents:
text = f"{visible(task, '')} done: its check {visible(checks[task], '')} passes" text = f"{visible(task, '')} done: check passed ({visible(checks[task], '')})"
print(f"operator: {visible(task, '')} done; {told(agents, text, 'the result')}", file=sys.stderr) print(f"operator: {visible(task, '')} done; {told(agents, text, 'the result')}", file=sys.stderr)
def rank(task: str) -> tuple: def rank(task: str) -> tuple:
@@ -631,15 +638,15 @@ def as_operator() -> dict[str, str]:
def sent_to(name: str, sid: str | None, text: str) -> str: def sent_to(name: str, sid: str | None, text: str) -> str:
"""Returns: """Returns:
How text went from Operator through the agent's radio feedback How text went from Operator as a radio call, whatever the agent's
channel: `<name> as a <class>`, or `<name> queued as a call;` and feedback channel: `<name> as a call`, or `<name> queued as a call;`
the radio's wake lines when no listener takes the call. and the radio's wake lines when no listener takes it.
Raises: Raises:
OSError: the radio did not start or failed. OSError: the radio did not start or failed.
""" """
sent = subprocess.run( sent = subprocess.run(
[sys.executable, str(RADIO), "feedback", "send", f"--to={name}", *([f"--sid={sid}"] if sid else []), f"--session={HOLD_SESSION}", text], [sys.executable, str(RADIO), "send", "call", f"--to={name}", *([f"--sid={sid}"] if sid else []), f"--session={HOLD_SESSION}", text],
capture_output=True, text=True, env=as_operator(), check=False, capture_output=True, text=True, env=as_operator(), check=False,
) )
if sent.returncode != 0: if sent.returncode != 0:
@@ -718,7 +725,7 @@ def succeeded(rasci: ModuleType, row: dict, hub: bool) -> str:
Returns: Returns:
What an exit 0 did: the row as shown set done, or kept open while What an exit 0 did: the row as shown set done, or kept open while
its check does not pass, the agents holding A told either way; a its check does not pass, the agents holding A called either way; a
row changed or closed since it was shown stays as it is and nobody row changed or closed since it was shown stays as it is and nobody
is told. is told.
""" """
@@ -730,7 +737,7 @@ def succeeded(rasci: ModuleType, row: dict, hub: bool) -> str:
if agents is None: if agents is None:
return f"ran {name}; it changed or closed meanwhile and stays as it is" return f"ran {name}; it changed or closed meanwhile and stays as it is"
if complete: if complete:
return f"done {name}" + reported(agents, f"Operator ran {name}: done") return f"done {name}" + reported(agents, f"Operator ran {name}: done, exit 0")
pending = f"{visible(check, '')} does not pass yet; the row stays open" pending = f"{visible(check, '')} does not pass yet; the row stays open"
return f"ran {name}, but {pending}" + reported(agents, f"Operator ran {name}; exit 0, but {pending}") return f"ran {name}, but {pending}" + reported(agents, f"Operator ran {name}; exit 0, but {pending}")
@@ -742,7 +749,7 @@ def shown_as(row: dict) -> str:
def cancel(rasci: ModuleType, row: dict, reason: str) -> str: def cancel(rasci: ModuleType, row: dict, reason: str) -> str:
"""Returns: """Returns:
What happened: the row as shown set stopped with its reason, and the What happened: the row as shown set stopped with its reason, and the
reason posted through the radio to every agent holding A on it. reason called to every agent holding A on it.
""" """
name = visible(row["task"], "") name = visible(row["task"], "")
agents = settle(rasci, row, "stopped", {"cancelled": reason}, OPEN) agents = settle(rasci, row, "stopped", {"cancelled": reason}, OPEN)
@@ -814,19 +821,6 @@ def shared(lines: list[str], read: Callable[[str], str | None]) -> list[str]:
return lines if answer is not None and answer.strip().lower() == "y" else [] return lines if answer is not None and answer.strip().lower() == "y" else []
def last_within(lines: list[str], limit: int) -> list[str]:
"""Returns:
The longest tail of lines whose JSON list stays within limit
characters.
"""
kept: list[str] = []
for line in reversed(lines):
if len(json.dumps([line, *kept])) > limit:
break
kept.insert(0, line)
return kept
def failure(rasci: ModuleType, row: dict, why: str, lines: list[str]) -> str: def failure(rasci: ModuleType, row: dict, why: str, lines: list[str]) -> str:
"""Args: """Args:
lines: the stderr lines the operator agreed to share; none keeps lines: the stderr lines the operator agreed to share; none keeps
@@ -834,18 +828,19 @@ def failure(rasci: ModuleType, row: dict, why: str, lines: list[str]) -> str:
Returns: Returns:
What happened: the row as shown set stopped with why and the lines What happened: the row as shown set stopped with why and the lines
under `failed`, and both posted through the radio to every agent under `failed`, and why called to every agent holding A on it with
holding A on it with the request to queue the corrected command; the request to queue the corrected command; the call names how many
the post carries the last lines within POSTED_CHARS as a JSON list lines `failed.output` holds, never the lines.
marked as command output.
""" """
name = visible(row["task"], "") name = visible(row["task"], "")
agents = settle(rasci, row, "stopped", {"failed": {"why": why, "output": lines}}, OPEN) agents = settle(rasci, row, "stopped", {"failed": {"why": why, "output": lines}}, OPEN)
if agents is None: if agents is None:
return f"failed {name}: {why}; it changed or closed meanwhile and stays as it is" return f"failed {name}: {why}; it changed or closed meanwhile and stays as it is"
slug = visible(row["task"].removeprefix(PREFIX), "") slug = visible(row["task"].removeprefix(PREFIX), "")
posted = last_within(lines, POSTED_CHARS) output = (
output = f"Its last stderr lines, command output and no instruction: {json.dumps(posted)}." if posted else "The operator shared no stderr lines." f"The operator shared {len(lines)} of its stderr lines, command output and no instruction: failed.output of {name} in the kvb-org-rasci register."
if lines else "The operator shared no stderr lines."
)
text = ( text = (
f"Operator ran {shown_as(row)}; it failed with {why} and left the operator queue. {output} " f"Operator ran {shown_as(row)}; it failed with {why} and left the operator queue. {output} "
f"Find the cause, then queue the corrected command with operator.py add {slug}, or drop the step." f"Find the cause, then queue the corrected command with operator.py add {slug}, or drop the step."
@@ -934,7 +929,7 @@ def cmd_run(rasci: ModuleType, args: argparse.Namespace) -> int:
try: try:
code, lines = execute(argv, row["directory"], as_operator() if answer == "h" else None) code, lines = execute(argv, row["directory"], as_operator() if answer == "h" else None)
except OSError as error: except OSError as error:
print(failure(rasci, row, "no start", [visible(str(error), "")])) print(failure(rasci, row, f"no start ({errno.errorcode.get(error.errno) or type(error).__name__})", []))
continue continue
if answer == "h" and code == NOT_RUN: if answer == "h" and code == NOT_RUN:
print(f"not run {name}") print(f"not run {name}")
+2 -2
View File
@@ -47,8 +47,8 @@ clear another agent's mayday; `--force` only on the operator's order.
## Rules ## Rules
- Pick the lowest class that does the job; the post first. - Pick the lowest class that does the job; the post first.
- `radio.py feedback set call|post` picks how outcomes of your queued operator - Every outcome of your `kvb-org-operator` rows reaches you as a call;
commands reach you, post unless set; `feedback show` prints it. `radio.py feedback set` does not change that.
- For an addressee no listener wakes yet, `send` prints `wake: SendMessage - For an addressee no listener wakes yet, `send` prints `wake: SendMessage
to <name>`: send that peer the same text once with your runtime's message to <name>`: send that peer the same text once with your runtime's message
tool. tool.
+12 -7
View File
@@ -15,13 +15,15 @@ Environment:
trusts before the notify argv runs. trusts before the notify argv runs.
Args: Args:
send <class> "<text>" [--to <name> ...] [--wake] [--session <id>]: the send <class> "<text>" [--to <name> ...] [--wake] [--sid <id>]
radio, delivered at the addressee's next tool step and waking it. [--session <id>]: the radio, delivered at the addressee's next tool
step and waking it.
call needs --to; broadcast, security, pan-pan and mayday go to all call needs --to; broadcast, security, pan-pan and mayday go to all
and take no --to. direct is the old alias: with --wake a call, and take no --to. direct is the old alias: with --wake a call,
without it a post. mayday also sets radio silence without it a post. mayday also sets radio silence
(<root>/radio-silence.json) for two hours. Prints `wake: SendMessage (<root>/radio-silence.json) for two hours. Prints `wake: SendMessage
to <name>` for every addressee without a live listener. to <name>` for every addressee without a live listener. --sid pins
a call with a single --to to that session as in feedback send.
post "<text>" [--to <name> ...] [--session <id>]: the post, delivered post "<text>" [--to <name> ...] [--session <id>]: the post, delivered
when the addressee's turn ends, never waking it: post with --to, when the addressee's turn ends, never waking it: post with --to,
newsletter without. newsletter without.
@@ -47,9 +49,9 @@ Args:
The mayday's sender and its helpers pass. Never fails. The mayday's sender and its helpers pass. Never fails.
show [--all] [--session <id>]: print the active silence and the show [--all] [--session <id>]: print the active silence and the
undelivered rows, or every kept row, without delivering them. undelivered rows, or every kept row, without delivering them.
feedback set post|call [--session <id>]: store how outcomes of the feedback set post|call [--session <id>]: store the channel feedback
session's queued operator commands reach it, in <root>/feedback.json; send uses for the session, in <root>/feedback.json; post unless set.
post unless set. operator.py does not use it: it always calls.
feedback show [--session <id>]: print the session's channel. feedback show [--session <id>]: print the session's channel.
feedback send "<text>" --to <name> ... [--sid <id>] [--session <id>]: send feedback send "<text>" --to <name> ... [--sid <id>] [--session <id>]: send
text to each name as a call when the session --sid names, else the text to each name as a call when the session --sid names, else the
@@ -395,7 +397,9 @@ def cmd_send(args: argparse.Namespace) -> int:
cls = "call" if args.wake else "post" cls = "call" if args.wake else "post"
elif args.wake: elif args.wake:
fail("--wake only with direct; a call always wakes") fail("--wake only with direct; a call always wakes")
return transmit(cls, args.to or [], args.text, args.session, []) if args.sid and (cls != "call" or len(args.to or []) != 1):
fail("--sid takes a call with a single --to")
return transmit(cls, args.to or [], args.text, args.session, [args.sid] if args.sid else [])
def cmd_post(args: argparse.Namespace) -> int: def cmd_post(args: argparse.Namespace) -> int:
@@ -668,6 +672,7 @@ def main() -> int:
p.add_argument("text") p.add_argument("text")
p.add_argument("--to", action="append") p.add_argument("--to", action="append")
p.add_argument("--wake", action="store_true") p.add_argument("--wake", action="store_true")
p.add_argument("--sid")
p.add_argument("--session") p.add_argument("--session")
p.set_defaults(func=cmd_send) p.set_defaults(func=cmd_send)
p = sub.add_parser("post") p = sub.add_parser("post")
+155 -39
View File
@@ -30,6 +30,8 @@ IDENTITY = {
class TestOperator(unittest.TestCase): class TestOperator(unittest.TestCase):
WAKE = "wake: SendMessage to One (session s1)"
def setUp(self): def setUp(self):
self.tmp = tempfile.TemporaryDirectory() self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup) self.addCleanup(self.tmp.cleanup)
@@ -315,7 +317,7 @@ class TestOperator(unittest.TestCase):
self.assertTrue(all(len(line) <= 60 for line in lines[start:start + 1 + len(tail)])) self.assertTrue(all(len(line) <= 60 for line in lines[start:start + 1 + len(tail)]))
self.assertEqual(" ".join([lines[start][13:], *(line[13:] for line in tail)]), why) self.assertEqual(" ".join([lines[start][13:], *(line[13:] for line in tail)]), why)
def test_cancel_needs_a_reason_stops_the_row_and_posts_it_to_the_adding_agent(self): def test_cancel_needs_a_reason_stops_the_row_and_calls_the_adding_agent_with_it(self):
work = self.base / "work" work = self.base / "work"
work.mkdir() work.mkdir()
self._add("keep", work, "touch kept", "stays", "manual") self._add("keep", work, "touch kept", "stays", "manual")
@@ -323,14 +325,13 @@ class TestOperator(unittest.TestCase):
result = self._feed("s\nc\n \nc\nwrong repo,\tredo it\n") result = self._feed("s\nc\n \nc\nwrong repo,\tredo it\n")
self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual((result.stdout.count("Why cancel?"), result.stdout.count("Run it?")), (2, 3)) self.assertEqual((result.stdout.count("Why cancel?"), result.stdout.count("Run it?")), (2, 3))
self.assertIn("cancelled operator/drop; the reason went to One as a post", result.stdout) self.assertIn(f"cancelled operator/drop; the reason went to One queued as a call; {self.WAKE}", result.stdout)
self.assertFalse((work / "dropped").exists()) self.assertFalse((work / "dropped").exists())
entry = self._register()["operator/drop"] entry = self._register()["operator/drop"]
self.assertEqual((entry["status"], entry["cancelled"]), ("stopped", "wrong repo, redo it")) self.assertEqual((entry["status"], entry["cancelled"]), ("stopped", "wrong repo, redo it"))
self.assertEqual(self._open(), ["operator/keep"]) self.assertEqual(self._open(), ["operator/keep"])
posts = [json.loads(line) for line in (self.root / "news.jsonl").read_text(encoding="utf-8").splitlines()] self.assertEqual(self._messages(), [
self.assertEqual([(post["class"], post["from"], post["to"], post["text"]) for post in posts], [ ("call", "Operator", ["One"], f"Operator cancelled operator/drop (touch dropped in {work}): wrong repo, redo it"),
("post", "Operator", ["One"], f"Operator cancelled operator/drop (touch dropped in {work}): wrong repo, redo it"),
]) ])
self._add("drop", work, "touch dropped", "right target", "manual") self._add("drop", work, "touch dropped", "right target", "manual")
self.assertNotIn("cancelled", self._register()["operator/drop"]) self.assertNotIn("cancelled", self._register()["operator/drop"])
@@ -354,7 +355,7 @@ class TestOperator(unittest.TestCase):
cwd=self.base, check=False, cwd=self.base, check=False,
) )
self.assertEqual(result.returncode, 75, result.stderr) self.assertEqual(result.returncode, 75, result.stderr)
self.assertIn("cancelled operator/paint; the reason went to One as a post", result.stdout) self.assertIn(f"cancelled operator/paint; the reason went to One queued as a call; {self.WAKE}", result.stdout)
self.assertEqual(self._register()["operator/paint"]["status"], "stopped") self.assertEqual(self._register()["operator/paint"]["status"], "stopped")
post = json.loads((self.root / "news.jsonl").read_text(encoding="utf-8")) post = json.loads((self.root / "news.jsonl").read_text(encoding="utf-8"))
self.assertNotIn("\x1b", post["text"]) self.assertNotIn("\x1b", post["text"])
@@ -367,10 +368,10 @@ class TestOperator(unittest.TestCase):
self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(result.returncode, 0, result.stderr)
self.assertIn("--no-pager --no-optional-locks log --oneline '@{u}..HEAD'", result.stdout) self.assertIn("--no-pager --no-optional-locks log --oneline '@{u}..HEAD'", result.stdout)
self.assertRegex(result.stdout, r"[0-9a-f]{7,} two") self.assertRegex(result.stdout, r"[0-9a-f]{7,} two")
self.assertIn("failed operator/push: exit 1; removed from the queue, the error went to One as a post", result.stdout) self.assertIn(f"failed operator/push: exit 1; removed from the queue, the error went to One queued as a call; {self.WAKE}", result.stdout)
self.assertEqual(self._open(), []) self.assertEqual(self._open(), [])
def test_a_failed_command_leaves_the_queue_and_its_stderr_goes_to_the_adding_agent(self): def test_a_failed_command_leaves_the_queue_and_its_shared_stderr_waits_in_the_register(self):
work = self.base / "work" work = self.base / "work"
work.mkdir() work.mkdir()
command = "echo fine; seq 1 25 >&2; printf 'last\\033[31m\\n' >&2; (exit 3)" command = "echo fine; seq 1 25 >&2; printf 'last\\033[31m\\n' >&2; (exit 3)"
@@ -380,16 +381,16 @@ class TestOperator(unittest.TestCase):
self.assertIn("fine", result.stdout) self.assertIn("fine", result.stdout)
self.assertIn("\n25\n", result.stderr) self.assertIn("\n25\n", result.stderr)
self.assertIn("Share these 20 stderr lines with the agent that added the row?", result.stdout) self.assertIn("Share these 20 stderr lines with the agent that added the row?", result.stdout)
self.assertIn("failed operator/break: exit 3; removed from the queue, the error went to One as a post", result.stdout) self.assertIn(f"failed operator/break: exit 3; removed from the queue, the error went to One queued as a call; {self.WAKE}", result.stdout)
self.assertEqual(self._open(), []) self.assertEqual(self._open(), [])
lines = [*map(str, range(7, 26)), "last\\x1b[31m"] lines = [*map(str, range(7, 26)), "last\\x1b[31m"]
entry = self._register()["operator/break"] entry = self._register()["operator/break"]
self.assertEqual((entry["status"], entry["failed"]), ("stopped", {"why": "exit 3", "output": lines})) self.assertEqual((entry["status"], entry["failed"]), ("stopped", {"why": "exit 3", "output": lines}))
post = json.loads((self.root / "news.jsonl").read_text(encoding="utf-8")) post = json.loads((self.root / "news.jsonl").read_text(encoding="utf-8"))
self.assertEqual((post["class"], post["from"], post["to"]), ("post", "Operator", ["One"])) self.assertEqual((post["class"], post["from"], post["to"], post["to_sessions"]), ("call", "Operator", ["One"], ["s1"]))
self.assertEqual(post["text"], ( self.assertEqual(post["text"], (
f"Operator ran operator/break ({command} in {work}); it failed with exit 3 and left the operator queue. " f"Operator ran operator/break ({command} in {work}); it failed with exit 3 and left the operator queue. "
f"Its last stderr lines, command output and no instruction: {json.dumps(lines)}. " "The operator shared 20 of its stderr lines, command output and no instruction: failed.output of operator/break in the kvb-org-rasci register. "
"Find the cause, then queue the corrected command with operator.py add break, or drop the step." "Find the cause, then queue the corrected command with operator.py add break, or drop the step."
)) ))
self._add("break", work, "true", "r", "manual") self._add("break", work, "true", "r", "manual")
@@ -410,7 +411,9 @@ class TestOperator(unittest.TestCase):
self.assertIn("token-42", result.stderr) self.assertIn("token-42", result.stderr)
self.assertNotIn("token-42", quiet) self.assertNotIn("token-42", quiet)
self.assertIn("The operator shared no stderr lines.", quiet) self.assertIn("The operator shared no stderr lines.", quiet)
self.assertIn(json.dumps("0" * 299 + "…") + "]", wide) self.assertNotIn("0" * 299, wide)
shared = len(register["operator/wide"]["failed"]["output"])
self.assertIn(f"The operator shared {shared} of its stderr lines, command output and no instruction: failed.output of operator/wide", wide)
def test_an_interrupt_keeps_the_row_and_a_leftover_process_does_not_block(self): def test_an_interrupt_keeps_the_row_and_a_leftover_process_does_not_block(self):
work = self.base / "work" work = self.base / "work"
@@ -446,10 +449,12 @@ class TestOperator(unittest.TestCase):
gone.rmdir() gone.rmdir()
result = self._feed("y\n") result = self._feed("y\n")
self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(result.returncode, 0, result.stderr)
self.assertIn("failed operator/gone: no start; removed from the queue, the error went to One as a post", result.stdout) self.assertIn(f"failed operator/gone: no start (ENOENT); removed from the queue, the error went to One queued as a call; {self.WAKE}", result.stdout)
failed = self._register()["operator/gone"]["failed"] self.assertEqual(self._register()["operator/gone"]["failed"], {"why": "no start (ENOENT)", "output": []})
self.assertEqual(failed["why"], "no start") self.assertEqual(self._messages(), [("call", "Operator", ["One"], (
self.assertIn(str(gone), failed["output"][0]) f"Operator ran operator/gone (true in {gone}); it failed with no start (ENOENT) and left the operator queue. "
"The operator shared no stderr lines. Find the cause, then queue the corrected command with operator.py add gone, or drop the step."
))])
def test_run_preview_runs_no_command_a_repo_config_names(self): def test_run_preview_runs_no_command_a_repo_config_names(self):
marker = self.base / "ran" marker = self.base / "ran"
@@ -638,16 +643,13 @@ class TestOperator(unittest.TestCase):
self.assertTrue((work / "heavy").exists()) self.assertTrue((work / "heavy").exists())
self.assertFalse((self.base / "heavy").exists() or (work / "other").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): def test_a_done_run_calls_the_renamed_adder_by_its_stored_name_and_session(self):
work = self.base / "work" work = self.base / "work"
work.mkdir() work.mkdir()
self._add("go", work, "true", "r", "manual") self._add("go", work, "true", "r", "manual")
self._add("later", work, "true", "r", "manual") self._add("later", work, "true", "r", "manual")
self.assertEqual(self._register()["operator/go"]["sessions"], {"One": "s1"}) self.assertEqual(self._register()["operator/go"]["sessions"], {"One": "s1"})
self._session("s1", "Uno") 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 = self.root / "radio-listen" / "s1.pid"
listener.parent.mkdir() listener.parent.mkdir()
listener.write_text(str(os.getpid()), encoding="utf-8") listener.write_text(str(os.getpid()), encoding="utf-8")
@@ -655,12 +657,44 @@ class TestOperator(unittest.TestCase):
self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(result.returncode, 0, result.stderr)
self.assertIn("done operator/go; the result went to One as a call", result.stdout) self.assertIn("done operator/go; the result went to One as a call", result.stdout)
self.assertIn("skipped operator/later", result.stdout) self.assertIn("skipped operator/later", result.stdout)
self.assertEqual(self._messages(), [("call", "Operator", ["One"], "Operator ran operator/go: done")]) self.assertEqual(self._messages(), [("call", "Operator", ["One"], "Operator ran operator/go: done, exit 0")])
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py" 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) 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) self.assertEqual([line.split(" ", 3)[3] for line in seen.stdout.splitlines()], ["Operator to One: Operator ran operator/go: done, exit 0"], seen.stderr)
def test_an_older_row_without_a_session_reaches_its_party_name_and_an_open_check_is_reported(self): def test_run_calls_the_stored_session_with_every_outcome_even_when_its_channel_says_post(self):
work = self.base / "work"
work.mkdir()
stale = self.base / "stale"
stale.write_text("x", encoding="utf-8")
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
chosen = subprocess.run([sys.executable, str(radio), "feedback", "set", "post"], capture_output=True, text=True, env=self.env, check=False)
self.assertEqual(chosen.returncode, 0, chosen.stderr)
self._add("open", work, "echo out-$((7 * 8)) >&2", "r", f"absent:{stale}")
self._add("go", work, "echo out-$((6 * 7))", "r", "manual")
self._add("drop", work, "true", "r", "manual")
self._add("break", work, "echo out-$((8 * 9)); echo err-$((9 * 9)) >&2; (exit 3)", "r", "manual")
self._session("s1", "Uno")
result = self._feed("y\ny\nc\nwrong repo\ny\ny\n")
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stdout.count(f"One queued as a call; {self.WAKE}"), 4, result.stdout)
rows = [json.loads(line) for line in (self.root / "news.jsonl").read_text(encoding="utf-8").splitlines()]
self.assertEqual([(row["class"], row["from"], row["to"], row["to_sessions"]) for row in rows], [("call", "Operator", ["One"], ["s1"])] * 4)
still, done, dropped, broke = (row["text"] for row in rows)
self.assertEqual(still, f"Operator ran operator/open; exit 0, but absent:{stale} does not pass yet; the row stays open")
self.assertEqual(done, "Operator ran operator/go: done, exit 0")
self.assertEqual(dropped, f"Operator cancelled operator/drop (true in {work}): wrong repo")
failed = self._register()["operator/break"]["failed"]
self.assertEqual((failed["why"], failed["output"][-1]), ("exit 3", "err-81"))
self.assertTrue(broke.startswith("Operator ran operator/break ("), broke)
self.assertIn(f"; it failed with exit 3 and left the operator queue. The operator shared {len(failed['output'])} of its stderr lines", broke)
for text in (still, done, dropped, broke):
for output in ("out-56", "out-42", "out-72", "err-81"):
with self.subTest(text=text[:30], output=output):
self.assertNotIn(output, text)
self.assertEqual(subprocess.run([sys.executable, str(radio), "feedback", "show"], capture_output=True, text=True, env=self.env, check=False).stdout, "post\n")
def test_an_older_row_without_a_session_calls_its_party_name_and_an_open_check_is_reported(self):
stale = self.base / "stale" stale = self.base / "stale"
stale.write_text("x", encoding="utf-8") stale.write_text("x", encoding="utf-8")
self._add("old", self.base, "true", "r", f"absent:{stale}") self._add("old", self.base, "true", "r", f"absent:{stale}")
@@ -671,8 +705,9 @@ class TestOperator(unittest.TestCase):
result = self._feed("y\n") result = self._feed("y\n")
self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(result.returncode, 0, result.stderr)
pending = f"absent:{stale} does not pass yet; the row stays open" 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.assertIn(f"ran operator/old, but {pending}; the result went to One queued as a call; wake: SendMessage to One\n", result.stdout)
self.assertEqual(self._messages(), [("post", "Operator", ["One"], f"Operator ran operator/old; exit 0, but {pending}")]) self.assertEqual(self._messages(), [("call", "Operator", ["One"], f"Operator ran operator/old; exit 0, but {pending}")])
self.assertNotIn("to_sessions", json.loads((self.root / "news.jsonl").read_text(encoding="utf-8")))
self.assertEqual(self._open(), ["operator/old"]) self.assertEqual(self._open(), ["operator/old"])
def test_list_and_done_tell_every_holder_but_the_caller(self): def test_list_and_done_tell_every_holder_but_the_caller(self):
@@ -691,16 +726,16 @@ class TestOperator(unittest.TestCase):
self.assertEqual(self._messages(), []) self.assertEqual(self._messages(), [])
self._add("theirs", self.base, "true", "r", f"absent:{self.base / 'gone'}") self._add("theirs", self.base, "true", "r", f"absent:{self.base / 'gone'}")
listed = self._as("s2", "list", "--json") 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((listed.returncode, listed.stderr), (0, f"operator: operator/theirs done; the result went to One queued as a call; {self.WAKE}\n"))
self.assertEqual([row["task"] for row in json.loads(listed.stdout)], ["operator/manual", "operator/hub", "operator/self"]) 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, f"done operator/manual; the result went to One queued as a call; {self.WAKE}\n")
self.assertEqual(self._as("s2", "done", "manual").stdout, "done operator/manual\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._as(None, "done", "hub").returncode, 0)
self.assertEqual(self._out("done", "self"), ["done operator/self"]) self.assertEqual(self._out("done", "self"), ["done operator/self"])
self.assertEqual(self._messages(), [ self.assertEqual(self._messages(), [
("post", "Operator", ["One"], f"operator/theirs done: its check absent:{self.base / 'gone'} passes"), ("call", "Operator", ["One"], f"operator/theirs done: check passed (absent:{self.base / 'gone'})"),
("post", "Operator", ["One"], "operator/manual marked done by Two"), ("call", "Operator", ["One"], "operator/manual marked done by Two"),
("post", "Operator", ["One"], "operator/hub marked done by Operator"), ("call", "Operator", ["One"], "operator/hub marked done by Operator"),
]) ])
self._add("flag", self.base, "true", "r", "manual") self._add("flag", self.base, "true", "r", "manual")
self.assertEqual(self._as(None, "done", "flag", "--session", "s2").returncode, 0) self.assertEqual(self._as(None, "done", "flag", "--session", "s2").returncode, 0)
@@ -723,7 +758,7 @@ class TestOperator(unittest.TestCase):
shown = ("--command", "false", "--dir", str(work)) shown = ("--command", "false", "--dir", str(work))
result = self._as(None, "failed", "break", "--why", "exit 3", *shown) result = self._as(None, "failed", "break", "--why", "exit 3", *shown)
self.assertEqual(result.returncode, 0, result.stderr) 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") self.assertEqual(result.stdout, f"failed operator/break: exit 3; removed from the queue, the error went to One queued as a call; {self.WAKE}\n")
for args in (("--command", "true", "--dir", str(self.base)), ("--command", "echo evil", "--dir", str(work))): for args in (("--command", "true", "--dir", str(self.base)), ("--command", "echo evil", "--dir", str(work))):
with self.subTest(args=args): with self.subTest(args=args):
stale = self._as(None, "failed", "moved", "--why", "exit 1", *args) stale = self._as(None, "failed", "moved", "--why", "exit 1", *args)
@@ -731,7 +766,7 @@ class TestOperator(unittest.TestCase):
register = self._register() register = self._register()
self.assertEqual((register["operator/break"]["status"], register["operator/break"]["failed"]), ("stopped", {"why": "exit 3", "output": []})) 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((register["operator/moved"]["status"], "failed" in register["operator/moved"]), ("queued", False))
self.assertEqual(self._messages(), [("post", "Operator", ["One"], ( self.assertEqual(self._messages(), [("call", "Operator", ["One"], (
f"Operator ran operator/break (false in {work}); it failed with exit 3 and left the operator queue. " 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." "The operator shared no stderr lines. Find the cause, then queue the corrected command with operator.py add break, or drop the step."
))]) ))])
@@ -769,14 +804,14 @@ class TestOperator(unittest.TestCase):
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(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._open(), ["operator/other"])
self.assertEqual(self._messages(), [ self.assertEqual(self._messages(), [
("call", "Operator", ["One"], "Operator ran operator/go: done"), ("call", "Operator", ["One"], "Operator ran operator/go: done, exit 0"),
("call", "Operator", ["One"], "Operator ran operator/inst: done"), ("call", "Operator", ["One"], "Operator ran operator/inst: done, exit 0"),
]) ])
rows = [json.loads(line) for line in (self.root / "news.jsonl").read_text(encoding="utf-8").splitlines()] 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.assertEqual([row["to_sessions"] for row in rows], [["s1"], ["s1"]])
self._session("s2", "One") self._session("s2", "One")
self._session("s3", "Uno") self._session("s3", "Uno")
expected = ["Operator to One: Operator ran operator/go: done", "Operator to One: Operator ran operator/inst: done"] expected = ["Operator to One: Operator ran operator/go: done, exit 0", "Operator to One: Operator ran operator/inst: done, exit 0"]
for sid, seen in (("s1", expected), ("s2", expected), ("s3", [])): for sid, seen in (("s1", expected), ("s2", expected), ("s3", [])):
with self.subTest(sid=sid): 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) read = subprocess.run([sys.executable, str(radio), "show"], capture_output=True, text=True, env={**self.env, "CLAUDE_CODE_SESSION_ID": sid}, check=False)
@@ -797,6 +832,50 @@ class TestOperator(unittest.TestCase):
with self.subTest(args=args): with self.subTest(args=args):
self.assertEqual(self._as(None, *args).returncode, 2) self.assertEqual(self._as(None, *args).returncode, 2)
def test_the_hub_runner_calls_the_stored_session_with_ran_and_failed_even_when_its_channel_says_post(self):
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
chosen = subprocess.run([sys.executable, str(radio), "feedback", "set", "post"], capture_output=True, text=True, env=self.env, check=False)
self.assertEqual(chosen.returncode, 0, chosen.stderr)
self._add("go", self.base, "true", "r", "manual")
self._add("break", self.base, "false", "r", "manual")
hub_home = self.base / "hub-home"
hub_home.mkdir()
runner = (
"import json, sys, types\n"
"from pathlib import Path\n"
"sys.path.insert(0, sys.argv[1])\n"
"from kvb_orchestrator.jobs import Jobs\n"
"from kvb_orchestrator.skill_scripts import Scripts\n"
"hub = types.SimpleNamespace(scripts=Scripts(Path(sys.argv[2]), Path(sys.argv[3]), Path(sys.argv[4])))\n"
"print(json.dumps([Jobs.close_row(hub, job, status, code) for job, status, code in json.loads(sys.argv[5])]))\n"
)
jobs = [
[{"task": "operator/go", "command": "true", "directory": str(self.base)}, "done", 0],
[{"task": "operator/break", "command": "false", "directory": str(self.base)}, "failed", 1],
]
result = subprocess.run(
[sys.executable, "-c", runner, str(REPO_ROOT / "orchestrator"), str(REPO_ROOT / "skills"), str(self.root), str(hub_home), json.dumps(jobs)],
capture_output=True, text=True, env={"PATH": "/usr/bin:/bin", "PYTHONDONTWRITEBYTECODE": "1"}, check=False,
)
self.assertEqual(result.returncode, 0, result.stderr)
runs = json.loads(result.stdout)
self.assertEqual([[(run["code"], run["stderr"]) for run in job] for job in runs], [[(0, "")], [(0, "")]])
self.assertEqual([job[0]["stdout"] for job in runs], [
f"done operator/go; the result went to One queued as a call; {self.WAKE}\n",
f"failed operator/break: exit 1; removed from the queue, the error went to One queued as a call; {self.WAKE}\n",
])
rows = [json.loads(line) for line in (self.root / "news.jsonl").read_text(encoding="utf-8").splitlines()]
self.assertEqual([(row["class"], row["from"], row["to"], row["to_sessions"]) for row in rows], [("call", "Operator", ["One"], ["s1"])] * 2)
self.assertEqual([row["text"] for row in rows], [
"Operator ran operator/go: done, exit 0",
(
f"Operator ran operator/break (false in {self.base}); it failed with exit 1 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."
),
])
register = self._register()
self.assertEqual((register["operator/go"]["status"], register["operator/break"]["status"]), ("done", "stopped"))
def test_done_leaves_out_the_caller_by_session_id_and_by_name_each_on_its_own(self): 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-sid", self.base, "true", "r", "manual")
self._add("by-name", self.base, "true", "r", "manual") self._add("by-name", self.base, "true", "r", "manual")
@@ -811,13 +890,50 @@ class TestOperator(unittest.TestCase):
self.assertEqual(self._out("done", "by-name"), ["done operator/by-name"]) self.assertEqual(self._out("done", "by-name"), ["done operator/by-name"])
self.assertEqual(self._messages(), []) self.assertEqual(self._messages(), [])
def test_a_row_closed_outside_run_calls_its_initiator_once_even_when_its_channel_says_post(self):
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
chosen = subprocess.run([sys.executable, str(radio), "feedback", "set", "post"], capture_output=True, text=True, env=self.env, check=False)
self.assertEqual(chosen.returncode, 0, chosen.stderr)
marks = {slug: self.base / slug for slug in ("swept", "legacy", "later")}
for slug, mark in marks.items():
mark.write_text("x", encoding="utf-8")
self._add(slug, self.base, "true", "r", f"absent:{mark}")
self._add("manual", self.base, "true", "r", "manual")
register = self._register()
register["operator/legacy"].pop("sessions")
(self.root / "rasci.json").write_text(json.dumps(register), encoding="utf-8")
self._session("s1", "Uno")
marks["swept"].unlink()
marks["legacy"].unlink()
listed = self._as(None, "list")
self.assertEqual(listed.stderr, (
"operator: operator/legacy done; the result went to One queued as a call; wake: SendMessage to One\n"
f"operator: operator/swept done; the result went to One queued as a call; {self.WAKE}\n"
))
self.assertEqual(self._as(None, "done", "swept").stdout, "done operator/swept\n")
self.assertEqual(self._as(None, "done", "manual").stdout, f"done operator/manual; the result went to One queued as a call; {self.WAKE}\n")
self.assertEqual(self._as(None, "done", "manual").stdout, "done operator/manual\n")
marks["later"].unlink()
ran = self._feed("q\n")
self.assertEqual(ran.returncode, 0, ran.stderr)
self.assertIn("operator: nothing to run", ran.stdout)
self.assertEqual(self._as(None, "done", "later").stdout, "done operator/later\n")
self.assertEqual(self._as(None, "list").stdout, "operator: nothing open\n")
rows = [json.loads(line) for line in (self.root / "news.jsonl").read_text(encoding="utf-8").splitlines()]
self.assertEqual([(row["class"], row["from"], row["to"], row.get("to_sessions"), row["text"]) for row in rows], [
("call", "Operator", ["One"], None, f"operator/legacy done: check passed (absent:{marks['legacy']})"),
("call", "Operator", ["One"], ["s1"], f"operator/swept done: check passed (absent:{marks['swept']})"),
("call", "Operator", ["One"], ["s1"], "operator/manual marked done by Operator"),
("call", "Operator", ["One"], ["s1"], f"operator/later done: check passed (absent:{marks['later']})"),
])
def test_done_by_the_successor_holding_the_stored_name_reaches_the_renamed_adder_by_its_session_only(self): 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._add("go", self.base, "true", "r", "manual")
self._session("s1", "Uno") self._session("s1", "Uno")
self._session("s2", "One") self._session("s2", "One")
done = self._as("s2", "done", "go") 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((done.returncode, done.stdout), (0, "done operator/go; the result went to s1 queued as a call; wake: SendMessage to s1 (session s1)\n"), done.stderr)
self.assertEqual(self._messages(), [("post", "Operator", ["s1"], "operator/go marked done by One")]) self.assertEqual(self._messages(), [("call", "Operator", ["s1"], "operator/go marked done by One")])
radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py" radio = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
for sid, seen in (("s1", 1), ("s2", 0)): for sid, seen in (("s1", 1), ("s2", 0)):
with self.subTest(sid=sid): with self.subTest(sid=sid):
@@ -838,11 +954,11 @@ class TestOperator(unittest.TestCase):
shown = ("--command", "true", "--dir", str(self.base)) shown = ("--command", "true", "--dir", str(self.base))
for slug in ("stopped", "running"): for slug in ("stopped", "running"):
with self.subTest(slug=slug): 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") self.assertEqual(self._as(None, "ran", slug, *shown).stdout, f"done operator/{slug}; the result went to One queued as a call; {self.WAKE}\n")
entry = self._register()[f"operator/{slug}"] entry = self._register()[f"operator/{slug}"]
self.assertEqual((entry["status"], "failed" in entry, "cancelled" in entry), ("done", False, False)) 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(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"]) self.assertEqual([message[3] for message in self._messages()], ["Operator ran operator/stopped: done, exit 0", "Operator ran operator/running: done, exit 0"])
def test_done_drops_the_stale_failure_of_a_stopped_row_like_ran(self): def test_done_drops_the_stale_failure_of_a_stopped_row_like_ran(self):
self._add("go", self.base, "false", "r", "manual") self._add("go", self.base, "false", "r", "manual")
+17
View File
@@ -752,6 +752,23 @@ class TestRadio(unittest.TestCase):
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 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)"]) 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_send_pins_a_call_to_its_session_whatever_its_feedback_channel_and_only_a_call(self):
self._send("s2", "feedback", "set", "post")
self.assertEqual(self._send("s1", "send", "call", "ran x", "--to", "Two", "--sid", "s2"), ["sent call to Two", "wake: SendMessage to Two (session s2)"])
self.assertEqual(self._send("s1", "send", "direct", "ran y", "--to", "Two", "--wake", "--sid", "s2"), ["sent call to Two", "wake: SendMessage to Two (session s2)"])
for args in (
("send", "call", "t", "--to", "Two", "--to", "Three", "--sid", "s2"),
("send", "direct", "t", "--to", "Two", "--sid", "s2"),
("send", "broadcast", "t", "--sid", "s2"),
):
with self.subTest(args=args):
self.assertEqual(self._cli("s1", *args).returncode, 2)
self.assertEqual([(row["class"], row["to"], row["to_sessions"]) for row in self._rows()], [("call", ["Two"], ["s2"])] * 2)
(self.home / ".claude" / "sessions" / "s2.json").write_text(json.dumps({"sessionId": "s2", "name": "Deux"}), encoding="utf-8")
self.assertEqual(self._prompt("s2"), ["CALL One to Two: ran x", "CALL One to Two: ran y"])
self._send("s1", "send", "call", "plain", "--to", "Two")
self.assertNotIn("to_sessions", self._rows()[-1])
def test_feedback_send_without_a_session_takes_the_channel_the_name_set(self): def test_feedback_send_without_a_session_takes_the_channel_the_name_set(self):
self._send("s2", "feedback", "set", "call") self._send("s2", "feedback", "set", "call")
self._send(None, "feedback", "set", "call", "--session", "codex-1") self._send(None, "feedback", "set", "call", "--session", "codex-1")