"""Committed tests for subagent orchestration and spill overflow (offline).
Covers the critic-fixed contract: spill threshold precedence over the
inline cap, preview shape with sibling truncated/nudge fields, delegate
approval (explore skips, plan/general ask), background handles with
task_output polling and cancel, session resume re-attaching spills and
interrupting live turns, and TUI generic cards for the new tools.
"""
# retoor <retoor@molodetz.nl>
import asyncio
import json
import os
import tempfile
import unittest
from blackcat.agent import BlackCatBot
from blackcat.fstate import FileState
from blackcat.orchestrate import SubagentManager, SubagentSpec
from blackcat.spill import SPILL_HEAD_CHARS, SPILL_THRESHOLD, SpillStore
from blackcat.tools import FileTools
def _bot(tmp, **kwargs):
kwargs.setdefault("provider", "echo")
kwargs.setdefault("system", "t")
kwargs.setdefault("tools", FileTools(FileState(tmp)))
return BlackCatBot(**kwargs)
class TestSpillStore(unittest.IsolatedAsyncioTestCase):
async def test_write_preview_shape(self):
with tempfile.TemporaryDirectory() as tmp:
store = SpillStore(tmp)
blob = "L\n" * 9000
preview = await store.write("read", blob)
self.assertTrue(preview["ok"])
self.assertTrue(preview["spilled"])
self.assertTrue(preview["truncated"])
self.assertIn("read_spill", preview["nudge"])
self.assertIn("handle", preview)
self.assertEqual(preview["shape"]["lines"], 9001)
self.assertLess(len(preview["preview_head"]), len(blob))
async def test_read_pages_and_filters(self):
with tempfile.TemporaryDirectory() as tmp:
store = SpillStore(tmp)
blob = "\n".join("line %d needle" % i if i % 2 else
"line %d plain" % i for i in range(500))
handle = (await store.write("grep", blob))["handle"]
page = await store.read(handle, offset=1, limit=10)
self.assertTrue(page["ok"])
self.assertEqual(page["shown"], 10)
self.assertTrue(page["truncated"])
self.assertIn("read_spill", page["nudge"])
hit = await store.read(handle, pattern="needle", limit=2000)
self.assertTrue(all("needle" in line for line in hit["lines"]))
self.assertGreater(hit["total_lines"], 200)
tail = await store.read(handle, limit=5, from_end=True)
self.assertIn("line 499 needle", tail["lines"][-1])
async def test_unknown_handle_carries_code(self):
with tempfile.TemporaryDirectory() as tmp:
store = SpillStore(tmp)
result = await store.read("spill-9999")
self.assertFalse(result["ok"])
self.assertEqual(result["code"], "unknown_handle")
async def test_index_roundtrip(self):
with tempfile.TemporaryDirectory() as tmp:
store = SpillStore(tmp)
handle = (await store.write("bash", "x" * (SPILL_THRESHOLD + 1))
)["handle"]
index = store.to_index()
fresh = SpillStore(tmp)
self.assertEqual(fresh.from_index(index), 1)
page = await fresh.read(handle)
self.assertTrue(page["ok"])
class TestEmitSpill(unittest.IsolatedAsyncioTestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
self.bot = _bot(self.tmp.name)
self.addAsyncCleanup(self.bot.aclose)
async def test_large_result_spills_with_handle_not_payload(self):
big = {"ok": True, "data": "y" * (SPILL_THRESHOLD + 5000)}
result = await self.bot.run_tool("todo", action="list")
self.assertTrue(result["ok"])
await self.bot._emit_tool_result("todo", big, None, {})
wire = self.bot.messages[-1]["content"]
payload = json.loads(wire)
self.assertTrue(payload["spilled"])
self.assertIn("handle", payload)
self.assertNotIn("y" * (SPILL_HEAD_CHARS + 1), wire)
self.assertLess(len(wire), len(json.dumps(big)))
full = [f for f in self.bot.transcript
if f.get("kind") == "tool" and f.get("out") == big]
self.assertEqual(len(full), 1)
page = await self.bot.run_tool(
"read_spill", handle=payload["handle"], limit=5)
self.assertTrue(page["ok"])
async def test_mid_size_keeps_legacy_truncation(self):
mid = {"ok": True, "data": "z" * 9000}
blob = json.dumps(mid)
self.assertGreater(len(blob), 8000)
self.assertLess(len(blob), SPILL_THRESHOLD)
await self.bot._emit_tool_result("todo", mid, None, {})
wire = self.bot.messages[-1]["content"]
self.assertIn("truncated", wire)
self.assertNotIn("spill", wire)
class TestDelegate(unittest.IsolatedAsyncioTestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
self.bot = _bot(self.tmp.name)
self.addAsyncCleanup(self.bot.aclose)
async def test_foreground_echo_returns_answer(self):
result = await self.bot.run_tool("delegate", task="scout the repo",
kind="explore")
self.assertTrue(result["ok"])
self.assertEqual(result["status"], "done")
self.assertIn("handle", result)
self.assertIn("scout the repo", result["answer"])
todos = self.bot.todo_list()
self.assertTrue(any("delegate(explore)" in t["text"] for t in todos))
self.assertTrue(all(t["status"] == "done" for t in todos
if "delegate(explore)" in t["text"]))
async def test_bad_kind_rejected(self):
result = await self.bot.run_tool("delegate", task="x", kind="nope")
self.assertFalse(result["ok"])
self.assertEqual(result["code"], "bad_args")
async def test_background_poll_to_done(self):
started = await self.bot.run_tool("delegate", task="bg work",
kind="general", background=True)
self.assertTrue(started["ok"])
self.assertEqual(started["status"], "running")
hid = started["handle"]
final = None
for _ in range(100):
poll = await self.bot.run_tool("task_output", handle=hid)
if poll.get("status") != "running":
final = poll
break
await asyncio.sleep(0.05)
self.assertIsNotNone(final)
self.assertTrue(final["ok"])
self.assertEqual(final["status"], "done")
self.assertIn("bg work", final["answer"])
async def test_resume_id_rereads_handle(self):
first = await self.bot.run_tool("delegate", task="again",
kind="plan")
reread = await self.bot.run_tool("delegate", task="ignored",
resume_id=first["handle"])
self.assertTrue(reread["ok"])
self.assertEqual(reread["handle"], first["handle"])
async def test_unknown_handle_carries_code(self):
result = await self.bot.run_tool("task_output", handle="sub-9999")
self.assertFalse(result["ok"])
self.assertEqual(result["code"], "unknown_handle")
async def test_explore_skips_confirm_general_asks(self):
denied = _bot(self.tmp.name,
tool_confirm=lambda name, args: False)
self.addAsyncCleanup(denied.aclose)
explore = await denied.run_tool("delegate", task="look",
kind="explore")
self.assertTrue(explore["ok"])
general = await denied.run_tool("delegate", task="do",
kind="general")
self.assertFalse(general["ok"])
self.assertEqual(general["code"], "rejected")
async def test_manager_cancel_running(self):
manager = SubagentManager()
spec = SubagentSpec(task="slow", kind="general", background=True)
handle = manager.new_handle(spec)
started = asyncio.Event()
async def _slow():
started.set()
await asyncio.sleep(30)
return {"ok": True}
manager.start_background(handle, _slow())
await started.wait()
outcome = manager.cancel(handle.hid)
self.assertTrue(outcome["ok"])
for _ in range(100):
if handle.status != "running":
break
await asyncio.sleep(0.05)
self.assertEqual(handle.status, "cancelled")
async def test_session_resume_interrupts_live_turns(self):
with tempfile.TemporaryDirectory() as tmp:
path = os.path.join(tmp, "s.json")
first = await self.bot.run_tool("delegate", task="done work",
kind="general")
await self.bot.save_session(path)
other = _bot(self.tmp.name, system="t")
self.addAsyncCleanup(other.aclose)
info = await other.load_session(path)
self.assertTrue(info["ok"])
self.assertEqual(info["subagents"], 1)
reread = await other.run_tool("task_output",
handle=first["handle"])
self.assertTrue(reread["ok"])
self.assertEqual(reread["status"], "done")
class TestNewCards(unittest.TestCase):
def test_factory_returns_generic_cards(self):
try:
from blackcat.tui import cards as tools_cards
except ImportError:
self.skipTest("tui extra unavailable")
for name in ("delegate", "task_output", "read_spill"):
card = tools_cards.CardFactory.create(name, 1, {})
self.assertIsInstance(card, tools_cards.GenericCard)
self.assertTrue(card.header_text())
if __name__ == "__main__":
unittest.main()