test+chore: close coverage gaps from multi-agent PR review

A 4-agent review found no correctness bugs in the diff; these address the
coverage gaps and one dead-code item it surfaced.

- daemon: test the real _run_agent_cycle_guarded timeout path -- a slow agent
  times out, its goal is abandoned and it's freed to IDLE, while a sibling
  completes (timeout isolation, previously only covered by an inline reimpl).
- daemon: test max_concurrent_agents validator (>=1) + default.
- store: test partial-migration recovery -- a half-applied migration (column
  added, user_version still 0) finishes cleanly on re-run via the column guards.
- clipboard: test _read_from_system_clipboard subprocess result handling
  (decoded stdout on success, None on nonzero return) with a faked subprocess.
- agent: test that a stream missing the terminal DONE event fails cleanly.
- api.py: drop the now-unused logger/logging (leftover from the removed
  _bounded_run monkeypatch).

Gate: 913 tests, ruff, format, mypy all green.

Author: chiruu12

src/hive/api.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import asyncio
-import logging
 from pathlib import Path
 from typing import Any
 from uuid import uuid4
@@ -15,8 +14,6 @@
 from hive.errors import AgentNotFoundError
 from hive.memory.store import HiveStore
 
-logger = logging.getLogger(__name__)
-
 
 def _run_sync(coro: Any) -> Any:
     """Run an async coroutine synchronously."""

tests/memory/test_store.py

@@ -116,6 +116,32 @@ async def test_upgrade_from_v0_adds_columns_and_keeps_data(self, tmp_path: Path)
         assert {"spawned_by", "max_cycles", "cycles_lived"} <= cols
         assert row is not None and row[0] == "Ada"  # pre-existing data survived
 
+    @pytest.mark.asyncio
+    async def test_partial_migration_recovers_on_rerun(self, tmp_path: Path) -> None:
+        """A half-applied migration (some columns added, version still 0) recovers.
+
+        The column-existence guards exist precisely so re-running initialize()
+        finishes the migration instead of erroring on the already-added column.
+        """
+        db_path = tmp_path / "state.db"
+        async with aiosqlite.connect(db_path) as db:
+            await db.executescript(_OLD_AGENTS_SCHEMA)
+            # Simulate a crash mid-_migration_1: spawned_by added, the rest not,
+            # and user_version never bumped.
+            await db.execute("ALTER TABLE agents ADD COLUMN spawned_by TEXT")
+            await db.execute("PRAGMA user_version = 0")
+            await db.commit()
+
+        await HiveStore(db_path).initialize()  # must not raise on the existing column
+
+        async with aiosqlite.connect(db_path) as db:
+            version = (await (await db.execute("PRAGMA user_version")).fetchone())[0]
+            cursor = await db.execute("PRAGMA table_info(agents)")
+            cols = {row[1] for row in await cursor.fetchall()}
+
+        assert version == LATEST_SCHEMA_VERSION
+        assert {"spawned_by", "max_cycles", "cycles_lived"} <= cols
+
     @pytest.mark.asyncio
     async def test_initialize_is_idempotent(self, tmp_path: Path) -> None:
         """Initializing twice is a no-op and does not error or change the version."""

tests/runtime/test_agent.py

@@ -428,9 +428,32 @@ async def generate_stream(self, *args: Any, **kwargs: Any):
         yield StreamEvent(type=StreamEventType.DONE, result=result)
 
 
+class NoDoneProvider(BaseProvider):
+    """Streams text but never emits the terminal DONE event (a broken provider)."""
+
+    @property
+    def available(self) -> bool:
+        return True
+
+    async def generate_with_metadata(self, *args: Any, **kwargs: Any) -> GenerateResult:
+        return GenerateResult(message=Message.assistant("x"), model="nodone")
+
+    async def generate_stream(self, *args: Any, **kwargs: Any):
+        yield StreamEvent(type=StreamEventType.TEXT, text="partial")
+        # intentionally no DONE event
+
+
 class TestStreaming:
     """A2: the agent's optional on_text path forwards streamed text deltas."""
 
+    @pytest.mark.asyncio
+    async def test_stream_without_done_event_fails_cleanly(self):
+        """A stream missing the terminal DONE event surfaces a clear failure."""
+        agent = Agent(name="x", model=NoDoneProvider("nodone"), on_text=lambda t: None)
+        result = await agent.run(Task(instruction="hi"))
+        assert result.status == TaskStatus.FAILED
+        assert "DONE" in (result.error or "")
+
     @pytest.mark.asyncio
     async def test_on_text_via_base_default(self):
         """A non-streaming provider still drives on_text via the base default."""

tests/test_daemon_concurrency.py

@@ -26,13 +26,13 @@ async def _seed(store: HiveStore, agent_id: str) -> None:
     )
 
 
-def _daemon(tmp_path: Path, max_concurrent: int) -> HiveDaemon:
+def _daemon(tmp_path: Path, max_concurrent: int, cycle_timeout: int = 0) -> HiveDaemon:
     # The daemon loads config in __init__, so set the global config AFTER
     # construction (read by _run at runtime) and disable economy on the instance.
     daemon = HiveDaemon(tmp_path / ".hive", heartbeat=0, logs_dir=tmp_path / "logs")
     cfg = HiveConfig()
     cfg.daemon.max_concurrent_agents = max_concurrent
-    cfg.daemon.cycle_timeout = 0  # no per-cycle timeout in these tests
+    cfg.daemon.cycle_timeout = cycle_timeout
     set_config(cfg)
     daemon._economy_enabled = False  # avoid life-event provider calls
     return daemon
@@ -92,3 +92,48 @@ async def fake_cycle(agent: AgentState) -> str:
         # The failing agent was isolated and marked ERROR.
         boom = await daemon._store.get_agent("boom")
         assert boom is not None and boom.status == AgentStatus.ERROR
+
+    @pytest.mark.asyncio
+    async def test_timeout_isolates_slow_agent(self, tmp_path: Path) -> None:
+        """A timed-out cycle abandons that agent's goal and frees it; siblings finish.
+
+        Drives the real _run_agent_cycle_guarded timeout path (not an inline copy).
+        """
+        daemon = _daemon(tmp_path, max_concurrent=8, cycle_timeout=1)
+        await daemon._store.initialize()
+        for aid in ["slow", "ok"]:
+            await _seed(daemon._store, aid)
+        await daemon._store.save_goal("g-slow", "slow", "a goal that will time out")
+
+        ran: set[str] = set()
+
+        async def fake_cycle(agent: AgentState) -> str:
+            if agent.agent_id == "slow":
+                await asyncio.sleep(5)  # exceeds the 1s cycle_timeout -> cancelled
+                return "completed"
+            ran.add(agent.agent_id)
+            return "completed"
+
+        daemon._run_agent_cycle = fake_cycle  # type: ignore[method-assign]
+        await daemon.start(max_cycles=1)
+
+        assert ran == {"ok"}  # the healthy agent completed despite the slow sibling
+        slow = await daemon._store.get_agent("slow")
+        assert slow is not None and slow.status == AgentStatus.IDLE  # freed, not stuck
+        goal = await daemon._store.get_goal_by_id("g-slow")
+        assert goal is not None and goal["status"] == "abandoned"
+
+
+class TestConcurrencyConfig:
+    def test_max_concurrent_agents_must_be_positive(self) -> None:
+        from pydantic import ValidationError
+
+        from hive.config import DaemonConfig
+
+        with pytest.raises(ValidationError, match="max_concurrent_agents"):
+            DaemonConfig(max_concurrent_agents=0)
+
+    def test_max_concurrent_agents_default(self) -> None:
+        from hive.config import DaemonConfig
+
+        assert DaemonConfig().max_concurrent_agents == 8

tests/tools/test_clipboard_read.py

@@ -48,3 +48,36 @@ async def test_read_clipboard_exposed_as_tool() -> None:
 async def test_helper_unsupported_platform(monkeypatch):
     monkeypatch.setattr(cb.platform, "system", lambda: "Windows")
     assert await cb._read_from_system_clipboard() is None
+
+
+class _FakeProc:
+    def __init__(self, returncode: int, stdout: bytes) -> None:
+        self.returncode = returncode
+        self._stdout = stdout
+
+    async def communicate(self):
+        return self._stdout, b""
+
+
+@pytest.mark.asyncio
+async def test_helper_reads_subprocess_stdout(monkeypatch):
+    """The macOS/Linux path returns decoded stdout when the command succeeds."""
+    monkeypatch.setattr(cb.platform, "system", lambda: "Darwin")
+
+    async def fake_exec(*cmd, **kwargs):
+        return _FakeProc(0, b"copied text\n")
+
+    monkeypatch.setattr(cb.asyncio, "create_subprocess_exec", fake_exec)
+    assert await cb._read_from_system_clipboard() == "copied text\n"
+
+
+@pytest.mark.asyncio
+async def test_helper_nonzero_returncode_is_none(monkeypatch):
+    """A failed clipboard command yields None (never raises)."""
+    monkeypatch.setattr(cb.platform, "system", lambda: "Linux")
+
+    async def fake_exec(*cmd, **kwargs):
+        return _FakeProc(1, b"")
+
+    monkeypatch.setattr(cb.asyncio, "create_subprocess_exec", fake_exec)
+    assert await cb._read_from_system_clipboard() is None