test(F1): cover CLI, MCP server, and structured logging (#34)

* test(F1): cover CLI, MCP server, and structured logging

Close the three biggest coverage gaps from the audit (F1), all additive:

- tests/cli/test_cli.py (17): Typer CliRunner over the read-only/no-daemon
  commands -- init (create + idempotent), the 'run hive init first' guards,
  status (empty), spawn (unknown profile + success->status), kill/nudge
  agent-not-found, tasks/notes/runs empty listings, models without a hive,
  and no-args help.
- tests/mcp/test_server.py (9): drive HiveMCPServer._handle_message directly
  (no stdio) -- initialize capabilities, tools/list schema, tools/call
  dispatch (spawn->status), error wrapping on missing args, unknown method
  -> None; handle_tool unknown-tool / unknown-profile / agent-not-found.
- tests/logging/test_writer_reader.py (9): LogWriter->LogReader round-trip
  for all record types, get_summary aggregation, run-dir layout, missing-run
  graceful handling, and a 50-thread concurrent-append smoke test.

996 tests pass; ruff/format/mypy/mkdocs clean.

* test(F1): address review — cwd-independent MCP spawn test + lock docstring

- Greptile: the MCP spawn test resolved profiles via the ambient cwd. The
  server fixture now chdir's into a tmp dir with its own profiles/coder.yaml,
  so default_profiles_dir() is deterministic regardless of where pytest runs.
- Greptile: correct the logging concurrency-test docstring -- the lock is
  module-level in writer.py, not an instance lock 'in the writer'.

(Did not add __init__.py to tests/cli|logging: tests/logging/__init__.py
shadows the stdlib logging module and breaks collection; several existing
test dirs -- tools/routing/stt/triggers -- also omit it. Unique test
basenames keep pytest's prepend import mode working.)

Author: chiruu12

tests/cli/test_cli.py

@@ -0,0 +1,134 @@
+"""CLI smoke/behavior tests via Typer's CliRunner (F1 coverage).
+
+Covers the read-only / no-daemon commands: argument parsing, exit codes, and
+error paths. The async TUI/daemon commands (start, watch, orchestrate, agent
+chat) are out of scope here.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from typer.testing import CliRunner
+
+from hive.cli.main import app
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def in_tmp_cwd(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+    """Run each command inside an isolated cwd (the CLI uses Path.cwd()/.hive)."""
+    monkeypatch.chdir(tmp_path)
+    return tmp_path
+
+
+def _init(in_tmp_cwd: Path) -> None:
+    result = runner.invoke(app, ["init"])
+    assert result.exit_code == 0
+
+
+def _write_profile(cwd: Path, name: str = "coder") -> None:
+    """Make `name`.yaml available to `hive spawn`, which reads cwd/profiles."""
+    dest_dir = cwd / "profiles"
+    dest_dir.mkdir(exist_ok=True)
+    (dest_dir / f"{name}.yaml").write_text(
+        f'name: {name}\nrole: "Test agent"\nmodel: claude-haiku-4-5\nautonomy: high\nmax_steps: 5\n'
+    )
+
+
+class TestInit:
+    def test_init_creates_hive(self, in_tmp_cwd: Path) -> None:
+        result = runner.invoke(app, ["init"])
+        assert result.exit_code == 0
+        assert (in_tmp_cwd / ".hive").is_dir()
+        assert (in_tmp_cwd / ".hive" / "hive.db").exists()
+
+    def test_init_idempotent(self, in_tmp_cwd: Path) -> None:
+        runner.invoke(app, ["init"])
+        result = runner.invoke(app, ["init"])
+        assert result.exit_code == 0
+        assert "already initialized" in result.output.lower()
+
+
+class TestGuardsRequireInit:
+    @pytest.mark.parametrize(
+        "args",
+        [["status"], ["spawn", "coder"], ["kill", "x"], ["nudge", "x", "hi"], ["tasks"]],
+    )
+    def test_commands_exit_1_without_hive(self, in_tmp_cwd: Path, args: list[str]) -> None:
+        result = runner.invoke(app, args)
+        assert result.exit_code == 1
+        assert "init" in result.output.lower()
+
+
+class TestStatus:
+    def test_status_empty(self, in_tmp_cwd: Path) -> None:
+        _init(in_tmp_cwd)
+        result = runner.invoke(app, ["status"])
+        assert result.exit_code == 0
+        assert "No agents" in result.output
+
+
+class TestSpawn:
+    def test_spawn_unknown_profile(self, in_tmp_cwd: Path) -> None:
+        _init(in_tmp_cwd)
+        result = runner.invoke(app, ["spawn", "ghost"])
+        assert result.exit_code == 1
+        assert "not found" in result.output.lower()
+
+    def test_spawn_success_then_status_lists_it(self, in_tmp_cwd: Path) -> None:
+        _init(in_tmp_cwd)
+        _write_profile(in_tmp_cwd, "coder")
+        result = runner.invoke(app, ["spawn", "coder"])
+        assert result.exit_code == 0
+        assert "Spawned" in result.output
+
+        status = runner.invoke(app, ["status"])
+        assert "coder" in status.output
+
+
+class TestAgentLookupErrors:
+    def test_kill_unknown_agent(self, in_tmp_cwd: Path) -> None:
+        _init(in_tmp_cwd)
+        result = runner.invoke(app, ["kill", "nobody"])
+        assert result.exit_code == 1
+        assert "not found" in result.output.lower()
+
+    def test_nudge_unknown_agent(self, in_tmp_cwd: Path) -> None:
+        _init(in_tmp_cwd)
+        result = runner.invoke(app, ["nudge", "nobody", "do the thing"])
+        assert result.exit_code == 1
+        assert "not found" in result.output.lower()
+
+
+class TestReadOnlyListings:
+    def test_tasks_empty(self, in_tmp_cwd: Path) -> None:
+        _init(in_tmp_cwd)
+        result = runner.invoke(app, ["tasks"])
+        assert result.exit_code == 0
+        assert "No pending tasks" in result.output
+
+    def test_notes_empty(self, in_tmp_cwd: Path) -> None:
+        _init(in_tmp_cwd)
+        result = runner.invoke(app, ["notes"])
+        assert result.exit_code == 0
+        assert "No notes" in result.output
+
+    def test_runs_empty(self, in_tmp_cwd: Path) -> None:
+        result = runner.invoke(app, ["runs"])
+        assert result.exit_code == 0
+        assert "No runs" in result.output
+
+    def test_models_runs_without_hive(self, in_tmp_cwd: Path) -> None:
+        # `models` inspects providers; it must not require an initialized hive.
+        result = runner.invoke(app, ["models"])
+        assert result.exit_code == 0
+
+
+class TestHelp:
+    def test_no_args_shows_help(self) -> None:
+        result = runner.invoke(app, [])
+        # no_args_is_help=True -> usage shown, non-crashing exit.
+        assert "Usage" in result.output or "Commands" in result.output

tests/logging/test_writer_reader.py

@@ -0,0 +1,146 @@
+"""Round-trip tests for the structured log writer/reader (F1 coverage)."""
+
+from __future__ import annotations
+
+import threading
+from pathlib import Path
+
+from hive.logging.models import (
+    CycleLog,
+    DecisionLog,
+    GoalLog,
+    SufferingLog,
+    ToolLog,
+)
+from hive.logging.reader import LogReader
+from hive.logging.writer import LogWriter
+
+
+def _start_run(writer: LogWriter) -> str:
+    return writer.start_run(
+        heartbeat=10,
+        profiles=["coder"],
+        agents=["a1"],
+        tools=["world_query"],
+    )
+
+
+class TestWriterReaderRoundTrip:
+    def test_start_run_creates_layout_and_run_json(self, tmp_path: Path) -> None:
+        writer = LogWriter(tmp_path)
+        run_id = _start_run(writer)
+
+        run_dir = tmp_path / "runs" / run_id
+        assert (run_dir / "run.json").exists()
+        assert (run_dir / "cycles").is_dir()
+        assert (run_dir / "agents").is_dir()
+
+        reader = LogReader(tmp_path)
+        run = reader.get_run(run_id)
+        assert run is not None
+        assert run.heartbeat == 10
+        assert run.profiles == ["coder"]
+        assert run.agents_spawned == ["a1"]
+
+    def test_all_record_types_round_trip(self, tmp_path: Path) -> None:
+        writer = LogWriter(tmp_path)
+        run_id = _start_run(writer)
+
+        writer.log_cycle(CycleLog(run_id=run_id, cycle=1, agents_active=1))
+        writer.log_goal(GoalLog(agent_id="a1", goal_id="g1", event="generated", objective="ship"))
+        writer.log_goal(GoalLog(agent_id="a1", goal_id="g1", event="completed", steps_done=3))
+        writer.log_decision(
+            DecisionLog(agent_id="a1", decision_type="goal", input_tokens=10, output_tokens=5)
+        )
+        writer.log_tool(ToolLog(agent_id="a1", tool_name="world_query", success=True))
+        writer.log_suffering(SufferingLog(agent_id="a1", cycle=1, cumulative_load=0.2))
+
+        reader = LogReader(tmp_path)
+        cycles = reader.get_cycles(run_id)
+        assert len(cycles) == 1 and cycles[0].agents_active == 1
+
+        goals = reader.get_agent_goals(run_id, "a1")
+        assert {g.event for g in goals} == {"generated", "completed"}
+
+        decisions = reader.get_agent_decisions(run_id, "a1")
+        assert len(decisions) == 1 and decisions[0].input_tokens == 10
+
+        tools = reader.get_agent_tools(run_id, "a1")
+        assert len(tools) == 1 and tools[0].tool_name == "world_query"
+
+        suffering = reader.get_agent_suffering(run_id, "a1")
+        assert len(suffering) == 1 and suffering[0].cumulative_load == 0.2
+
+        assert reader.get_agent_ids(run_id) == ["a1"]
+
+    def test_get_summary_aggregates(self, tmp_path: Path) -> None:
+        writer = LogWriter(tmp_path)
+        run_id = _start_run(writer)
+
+        writer.log_goal(GoalLog(agent_id="a1", goal_id="g1", event="generated"))
+        writer.log_goal(GoalLog(agent_id="a1", goal_id="g1", event="completed"))
+        writer.log_goal(GoalLog(agent_id="a1", goal_id="g2", event="generated"))
+        writer.log_goal(GoalLog(agent_id="a1", goal_id="g2", event="abandoned"))
+        writer.log_tool(ToolLog(agent_id="a1", tool_name="t", success=True))
+        writer.log_decision(
+            DecisionLog(
+                agent_id="a1",
+                decision_type="goal",
+                input_tokens=100,
+                output_tokens=50,
+                cost_usd=0.01,
+            )
+        )
+
+        summary = LogReader(tmp_path).get_summary(run_id)
+        assert summary["agents"] == 1
+        assert summary["goals_generated"] == 2
+        assert summary["goals_completed"] == 1
+        assert summary["goals_abandoned"] == 1
+        assert summary["tool_calls"] == 1
+        assert summary["total_tokens"] == 150
+        assert summary["total_cost_usd"] == 0.01
+
+
+class TestReaderMissingData:
+    def test_list_runs_empty_when_no_dir(self, tmp_path: Path) -> None:
+        assert LogReader(tmp_path).list_runs() == []
+
+    def test_get_missing_run_returns_none(self, tmp_path: Path) -> None:
+        LogWriter(tmp_path)  # creates runs/ dir but no run
+        assert LogReader(tmp_path).get_run("run-does-not-exist") is None
+
+    def test_summary_of_missing_run_is_empty(self, tmp_path: Path) -> None:
+        assert LogReader(tmp_path).get_summary("nope") == {}
+
+    def test_queries_on_missing_run_return_empty_lists(self, tmp_path: Path) -> None:
+        reader = LogReader(tmp_path)
+        assert reader.get_cycles("nope") == []
+        assert reader.get_agent_goals("nope", "a1") == []
+        assert reader.get_agent_ids("nope") == []
+
+    def test_list_runs_after_start(self, tmp_path: Path) -> None:
+        writer = LogWriter(tmp_path)
+        run_id = _start_run(writer)
+        runs = LogReader(tmp_path).list_runs()
+        assert [r.run_id for r in runs] == [run_id]
+
+
+class TestConcurrentWrites:
+    def test_concurrent_tool_logs_all_land(self, tmp_path: Path) -> None:
+        """The module-level threading.Lock guarding writes keeps concurrent appends intact."""
+        writer = LogWriter(tmp_path)
+        run_id = _start_run(writer)
+
+        def write(i: int) -> None:
+            writer.log_tool(ToolLog(agent_id="a1", tool_name=f"tool-{i}", success=True))
+
+        threads = [threading.Thread(target=write, args=(i,)) for i in range(50)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        tools = LogReader(tmp_path).get_agent_tools(run_id, "a1")
+        assert len(tools) == 50
+        assert {t.tool_name for t in tools} == {f"tool-{i}" for i in range(50)}

tests/mcp/test_server.py

@@ -0,0 +1,112 @@
+"""Tests for the Hive MCP server protocol + tool dispatch (F1 coverage).
+
+Drives HiveMCPServer message handling directly -- no stdio transport.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from hive.mcp.server import HiveMCPServer
+
+
+@pytest.fixture
+def server(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> HiveMCPServer:
+    # Run in an isolated cwd with its own profiles/ so the spawn path resolves
+    # `default_profiles_dir()` deterministically (it checks Path.cwd()/profiles
+    # first) instead of depending on the ambient working directory.
+    monkeypatch.chdir(tmp_path)
+    profiles = tmp_path / "profiles"
+    profiles.mkdir()
+    (profiles / "coder.yaml").write_text(
+        'name: coder\nrole: "Test agent"\nmodel: claude-haiku-4-5\nautonomy: high\nmax_steps: 5\n'
+    )
+    hive_dir = tmp_path / ".hive"
+    hive_dir.mkdir(parents=True)  # so the store's hive.db parent exists
+    return HiveMCPServer(hive_dir=hive_dir)
+
+
+class TestProtocol:
+    async def test_initialize_returns_capabilities(self, server: HiveMCPServer) -> None:
+        resp = await server._handle_message({"jsonrpc": "2.0", "id": 1, "method": "initialize"})
+        assert resp is not None
+        assert resp["id"] == 1
+        assert resp["result"]["protocolVersion"]
+        assert "tools" in resp["result"]["capabilities"]
+        assert resp["result"]["serverInfo"]["name"] == "hive"
+
+    async def test_tools_list_exposes_all_tools(self, server: HiveMCPServer) -> None:
+        resp = await server._handle_message({"jsonrpc": "2.0", "id": 2, "method": "tools/list"})
+        assert resp is not None
+        names = {t["name"] for t in resp["result"]["tools"]}
+        assert {"hive_init", "hive_start", "hive_status", "hive_spawn", "hive_models"} <= names
+        # Every tool advertises an input schema.
+        assert all("inputSchema" in t for t in resp["result"]["tools"])
+
+    async def test_unknown_method_returns_none(self, server: HiveMCPServer) -> None:
+        assert await server._handle_message({"id": 9, "method": "resources/list"}) is None
+
+
+class TestToolsCall:
+    async def test_status_on_empty_hive(self, server: HiveMCPServer) -> None:
+        resp = await server._handle_message(
+            {
+                "jsonrpc": "2.0",
+                "id": 3,
+                "method": "tools/call",
+                "params": {"name": "hive_status", "arguments": {}},
+            }
+        )
+        assert resp is not None
+        text = resp["result"]["content"][0]["text"]
+        assert "No agents" in text
+
+    async def test_spawn_then_status(self, server: HiveMCPServer) -> None:
+        spawn = await server._handle_message(
+            {
+                "jsonrpc": "2.0",
+                "id": 4,
+                "method": "tools/call",
+                "params": {"name": "hive_spawn", "arguments": {"profile": "coder"}},
+            }
+        )
+        assert "Spawned" in spawn["result"]["content"][0]["text"]
+
+        status = await server._handle_message(
+            {
+                "jsonrpc": "2.0",
+                "id": 5,
+                "method": "tools/call",
+                "params": {"name": "hive_status", "arguments": {}},
+            }
+        )
+        assert "coder" in status["result"]["content"][0]["text"]
+
+    async def test_missing_required_arg_is_caught(self, server: HiveMCPServer) -> None:
+        """A KeyError from a missing required arg becomes an error result, not a crash."""
+        resp = await server._handle_message(
+            {
+                "jsonrpc": "2.0",
+                "id": 6,
+                "method": "tools/call",
+                "params": {"name": "hive_spawn", "arguments": {}},  # missing "profile"
+            }
+        )
+        assert resp["result"]["content"][0]["text"].startswith("Error:")
+
+
+class TestHandleTool:
+    async def test_unknown_tool(self, server: HiveMCPServer) -> None:
+        assert await server.handle_tool("hive_teleport", {}) == "Unknown tool: hive_teleport"
+
+    async def test_spawn_unknown_profile(self, server: HiveMCPServer) -> None:
+        assert (await server.handle_tool("hive_spawn", {"profile": "ghost"})).startswith(
+            "Profile not found"
+        )
+
+    async def test_kill_missing_agent(self, server: HiveMCPServer) -> None:
+        assert (await server.handle_tool("hive_kill", {"agent": "nobody"})).startswith(
+            "Agent not found"
+        )