"""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 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()