agent-dispatch 0.2.0__tar.gz → 0.2.1__tar.gz

{agent_dispatch-0.2.0 → agent_dispatch-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-dispatch
-Version: 0.2.0
+Version: 0.2.1
 Summary: MCP server that lets Claude Code agents delegate tasks to agents in other project directories
 Project-URL: Homepage, https://github.com/ginkida/agent-dispatch
 Project-URL: Repository, https://github.com/ginkida/agent-dispatch

{agent_dispatch-0.2.0 → agent_dispatch-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-dispatch"
-version = "0.2.0"
+version = "0.2.1"
 description = "MCP server that lets Claude Code agents delegate tasks to agents in other project directories"
 readme = "README.md"
 license = "MIT"

{agent_dispatch-0.2.0 → agent_dispatch-0.2.1}/src/agent_dispatch/__init__.py

@@ -1,3 +1,3 @@
 """agent-dispatch: Delegate tasks between Claude Code agents across projects."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{agent_dispatch-0.2.0 → agent_dispatch-0.2.1}/src/agent_dispatch/cli.py

@@ -8,11 +8,31 @@ import subprocess
 from pathlib import Path
 
 import click
+import yaml
+from pydantic import ValidationError
 
 from .config import auto_describe, config_path, load_config, save_config
 from .models import AgentConfig, DispatchConfig, check_permission_mode, validate_agent_name
 
 
+def _load_or_exit() -> DispatchConfig:
+    """Load config, exiting with a friendly error on malformed YAML or schema."""
+    try:
+        return load_config()
+    except ValidationError as e:
+        click.echo(click.style(
+            f"Error: config at {config_path()} has an invalid schema:", fg="red"
+        ))
+        click.echo(str(e))
+        raise SystemExit(1)
+    except yaml.YAMLError as e:
+        click.echo(click.style(
+            f"Error: config at {config_path()} is not valid YAML:", fg="red"
+        ))
+        click.echo(str(e))
+        raise SystemExit(1)
+
+
 @click.group()
 @click.version_option(package_name="agent-dispatch")
 def cli() -> None:
@@ -107,7 +127,7 @@ def add(
         click.echo(f"Error: {e}")
         raise SystemExit(1)
 
-    config = load_config()
+    config = _load_or_exit()
     dir_path = Path(directory).resolve()
 
     if name in config.agents:
@@ -126,9 +146,9 @@ def add(
         max_budget_usd=max_budget,
         permission_mode=permission_mode,
         allowed_tools=[t.strip() for t in allowed_tools.split(",") if t.strip()]
-        if allowed_tools else [],
+        if allowed_tools else None,
         disallowed_tools=[t.strip() for t in disallowed_tools.split(",") if t.strip()]
-        if disallowed_tools else [],
+        if disallowed_tools else None,
     )
     if warning := check_permission_mode(permission_mode):
         click.echo(click.style(f"Warning: {warning}", fg="yellow"))
@@ -141,7 +161,7 @@ def add(
 @click.argument("name")
 def remove(name: str) -> None:
     """Remove an agent."""
-    config = load_config()
+    config = _load_or_exit()
     if name not in config.agents:
         click.echo(f"Agent '{name}' not found.")
         raise SystemExit(1)
@@ -154,14 +174,20 @@ def remove(name: str) -> None:
 @cli.command("list")
 def list_agents() -> None:
     """List configured agents with health status."""
-    config = load_config()
+    config = _load_or_exit()
     if not config.agents:
         click.echo("No agents configured. Run: agent-dispatch add <name> <directory>")
         return
 
     for name, agent in config.agents.items():
-        healthy = agent.directory.is_dir()
-        status = click.style("OK", fg="green") if healthy else click.style("NOT FOUND", fg="red")
+        try:
+            healthy = agent.directory.is_dir()
+            status_label = "OK" if healthy else "NOT FOUND"
+            status_color = "green" if healthy else "red"
+        except OSError:
+            status_label = "UNREADABLE"
+            status_color = "red"
+        status = click.style(status_label, fg=status_color)
         click.echo(f"  {name} [{status}]")
         click.echo(f"    dir:  {agent.directory}")
         click.echo(f"    desc: {agent.description}")
@@ -214,7 +240,7 @@ def update(
     disallowed_tools: str | None,
 ) -> None:
     """Update an existing agent's configuration."""
-    config = load_config()
+    config = _load_or_exit()
     if name not in config.agents:
         click.echo(f"Agent '{name}' not found. Run 'agent-dispatch list' to see agents.")
         raise SystemExit(1)
@@ -229,26 +255,27 @@ def update(
         agent.timeout = timeout
         updated.append("timeout")
     if model is not None:
-        agent.model = None if model.lower() == "none" else model
+        agent.model = None if model.strip().lower() in ("none", "") else model
         updated.append("model")
     if max_budget is not None:
         agent.max_budget_usd = None if max_budget == 0 else max_budget
         updated.append("max_budget_usd")
     if permission_mode is not None:
-        effective = None if permission_mode.lower() == "none" else permission_mode
+        stripped = permission_mode.strip()
+        effective = None if stripped.lower() in ("none", "") else stripped
         agent.permission_mode = effective
         if warning := check_permission_mode(effective):
             click.echo(click.style(f"Warning: {warning}", fg="yellow"))
         updated.append("permission_mode")
     if allowed_tools is not None:
-        if allowed_tools.lower() == "none":
-            agent.allowed_tools = []
+        if allowed_tools.strip().lower() in ("none", ""):
+            agent.allowed_tools = None
         else:
             agent.allowed_tools = [t.strip() for t in allowed_tools.split(",") if t.strip()]
         updated.append("allowed_tools")
     if disallowed_tools is not None:
-        if disallowed_tools.lower() == "none":
-            agent.disallowed_tools = []
+        if disallowed_tools.strip().lower() in ("none", ""):
+            agent.disallowed_tools = None
         else:
             agent.disallowed_tools = [
                 t.strip() for t in disallowed_tools.split(",") if t.strip()
@@ -268,7 +295,7 @@ def update(
 @click.argument("task", default="What project is this? Describe in one sentence.")
 def test(name: str, task: str) -> None:
     """Test an agent by dispatching a task."""
-    config = load_config()
+    config = _load_or_exit()
     if name not in config.agents:
         click.echo(f"Agent '{name}' not found. Run 'agent-dispatch list' to see agents.")
         raise SystemExit(1)

{agent_dispatch-0.2.0 → agent_dispatch-0.2.1}/src/agent_dispatch/models.py

@@ -15,14 +15,24 @@ KNOWN_PERMISSION_MODES = frozenset({
 
 def check_permission_mode(mode: str | None) -> str | None:
     """Return a warning message if mode is unknown, else None."""
-    if mode and mode not in KNOWN_PERMISSION_MODES:
+    if not mode:
+        return None
+    trimmed = mode.strip()
+    if not trimmed:
+        return None
+    if trimmed not in KNOWN_PERMISSION_MODES:
         known = ", ".join(sorted(KNOWN_PERMISSION_MODES))
-        return f"Unknown permission_mode: {mode!r}. Known values: {known}"
+        return f"Unknown permission_mode: {trimmed!r}. Known values: {known}"
     return None
 
 
 class AgentConfig(BaseModel):
-    """Configuration for a single agent."""
+    """Configuration for a single agent.
+
+    `allowed_tools` / `disallowed_tools` use `None` to mean
+    "inherit from settings.default_*" and `[]` to mean "explicitly empty
+    (override defaults to no tools)".
+    """
 
     directory: Path
     description: str = ""
@@ -30,8 +40,8 @@ class AgentConfig(BaseModel):
     max_budget_usd: float | None = None
     model: str | None = None
     permission_mode: str | None = None
-    allowed_tools: list[str] = Field(default_factory=list)
-    disallowed_tools: list[str] = Field(default_factory=list)
+    allowed_tools: list[str] | None = None
+    disallowed_tools: list[str] | None = None
 
     @field_validator("directory", mode="before")
     @classmethod

{agent_dispatch-0.2.0 → agent_dispatch-0.2.1}/src/agent_dispatch/runner.py

@@ -29,9 +29,14 @@ _PERMISSION_PATTERNS = [
 ]
 
 
-def _classify_error(error_text: str) -> str:
-    """Classify an error message into a category."""
-    lower = error_text.lower()
+def _classify_error(error_text: object) -> str:
+    """Classify an error message into a category.
+
+    Accepts any type and coerces to string — some claude CLI error paths
+    produce non-string values (None, dict) that would crash `.lower()`.
+    """
+    text = str(error_text) if error_text else ""
+    lower = text.lower()
     for pattern in _PERMISSION_PATTERNS:
         if pattern in lower:
             return "permission"
@@ -101,11 +106,18 @@ def _build_command(
     if permission_mode:
         cmd.extend(["--permission-mode", permission_mode])
 
-    allowed = agent.allowed_tools or settings.default_allowed_tools
+    # None = inherit from settings; [] = explicitly empty (no inheritance)
+    allowed = (
+        agent.allowed_tools if agent.allowed_tools is not None
+        else settings.default_allowed_tools
+    )
     for tool in allowed:
         cmd.extend(["--allowedTools", tool])
 
-    disallowed = agent.disallowed_tools or settings.default_disallowed_tools
+    disallowed = (
+        agent.disallowed_tools if agent.disallowed_tools is not None
+        else settings.default_disallowed_tools
+    )
     for tool in disallowed:
         cmd.extend(["--disallowedTools", tool])
 
@@ -227,22 +239,36 @@ def dispatch(
         data = json.loads(proc.stdout)
     except json.JSONDecodeError:
         # Fallback: treat stdout as plain text
+        success = proc.returncode == 0
+        text = proc.stdout.strip()
+        if success:
+            return DispatchResult(agent=agent_name, success=True, result=text)
+        error_text = text or f"claude exited with code {proc.returncode} (non-JSON output)"
+        error_type = _classify_error(error_text)
+        if error_type == "permission":
+            error_text += _permission_hint(agent_name)
         return DispatchResult(
             agent=agent_name,
-            success=proc.returncode == 0,
-            result=proc.stdout.strip(),
+            success=False,
+            result=text,
+            error=error_text,
+            error_type=error_type,
         )
 
     is_error = data.get("is_error", False)
     if is_error:
-        error_text = data.get("result", "")
+        raw_result = data.get("result", "")
+        error_text = str(raw_result) if raw_result else (
+            f"Agent '{agent_name}' reported an error with no details "
+            f"(exit code {proc.returncode})"
+        )
         error_type = _classify_error(error_text)
         if error_type == "permission":
             error_text += _permission_hint(agent_name)
         return DispatchResult(
             agent=agent_name,
             success=False,
-            result=data.get("result", ""),
+            result=str(raw_result) if raw_result else "",
             session_id=data.get("session_id"),
             cost_usd=data.get("total_cost_usd"),
             duration_ms=data.get("duration_ms"),
@@ -326,11 +352,21 @@ def dispatch_stream(
             text=True,
             env=env,
         )
-    except OSError as e:
+    except FileNotFoundError as e:
         return DispatchResult(
             agent=agent_name, success=False, result="", error=str(e),
             error_type="not_found",
         )
+    except PermissionError as e:
+        return DispatchResult(
+            agent=agent_name, success=False, result="", error=str(e),
+            error_type="permission",
+        )
+    except OSError as e:
+        return DispatchResult(
+            agent=agent_name, success=False, result="", error=str(e),
+            error_type="cli_error",
+        )
 
     # Kill the process if it exceeds the timeout
     timed_out = threading.Event()
@@ -387,14 +423,17 @@ def dispatch_stream(
     if result_data:
         is_error = result_data.get("is_error", False)
         if is_error:
-            error_text = result_data.get("result", "")
+            raw_result = result_data.get("result", "")
+            error_text = str(raw_result) if raw_result else (
+                f"Agent '{agent_name}' reported an error with no details"
+            )
             error_type = _classify_error(error_text)
             if error_type == "permission":
                 error_text += _permission_hint(agent_name)
             return DispatchResult(
                 agent=agent_name,
                 success=False,
-                result=result_data.get("result", ""),
+                result=str(raw_result) if raw_result else "",
                 session_id=result_data.get("session_id"),
                 cost_usd=result_data.get("total_cost_usd"),
                 duration_ms=result_data.get("duration_ms"),

{agent_dispatch-0.2.0 → agent_dispatch-0.2.1}/src/agent_dispatch/server.py

@@ -326,6 +326,7 @@ async def dispatch_parallel(
                 "success": False,
                 "result": "",
                 "error": str(res),
+                "error_type": "cli_error",
             })
         else:
             output.append(res)
@@ -421,16 +422,22 @@ async def dispatch_stream(
         # Forward progress messages while the subprocess runs
         while not future.done():
             await asyncio.sleep(0.1)
-            while not progress_queue.empty():
-                msg = progress_queue.get_nowait()
+            while True:
+                try:
+                    msg = progress_queue.get_nowait()
+                except queue.Empty:
+                    break
                 if ctx:
                     await ctx.info(f"[{agent}] {msg[:300]}")
 
         result = await asyncio.wrap_future(future)
 
         # Drain any remaining messages
-        while not progress_queue.empty():
-            msg = progress_queue.get_nowait()
+        while True:
+            try:
+                msg = progress_queue.get_nowait()
+            except queue.Empty:
+                break
             if ctx:
                 await ctx.info(f"[{agent}] {msg[:300]}")
 
@@ -642,7 +649,7 @@ async def add_agent(
         directory: Absolute path to the project directory.
         description: What this agent can do. Leave empty for auto-generation.
         timeout: Timeout in seconds (0 uses global default of 300).
-        max_budget_usd: Max cost in USD per dispatch (0 = no limit).
+        max_budget_usd: Max cost in USD per dispatch (0 or omitted = no limit).
         permission_mode: Permission mode for the claude CLI
             (e.g. default, plan, bypassPermissions). Leave empty for default.
         allowed_tools: Comma-separated list of allowed tools
@@ -666,8 +673,17 @@ async def add_agent(
         return json.dumps({"error": f"Agent '{name}' already exists. Remove it first."})
 
     desc = description or auto_describe(dir_path)
-    parsed_allowed = [t.strip() for t in allowed_tools.split(",") if t.strip()] if allowed_tools else []
-    parsed_disallowed = [t.strip() for t in disallowed_tools.split(",") if t.strip()] if disallowed_tools else []
+    parsed_allowed = (
+        [t.strip() for t in allowed_tools.split(",") if t.strip()]
+        if allowed_tools else None
+    )
+    parsed_disallowed = (
+        [t.strip() for t in disallowed_tools.split(",") if t.strip()]
+        if disallowed_tools else None
+    )
+
+    if ctx and (warning := check_permission_mode(permission_mode or None)):
+        await ctx.info(f"Warning: {warning}")
 
     config.agents[name] = AgentConfig(
         directory=dir_path,
@@ -681,8 +697,6 @@ async def add_agent(
     save_config(config)
 
     if ctx:
-        if warning := check_permission_mode(permission_mode or None):
-            await ctx.info(f"Warning: {warning}")
         await ctx.info(f"Added agent '{name}' -> {dir_path}")
 
     result: dict = {
@@ -746,8 +760,8 @@ async def update_agent(
         name: Agent name to update.
         description: New description.
         timeout: New timeout in seconds (0 = don't change).
-        max_budget_usd: Max cost in USD per dispatch (0 = don't change,
-            negative = clear limit).
+        max_budget_usd: New max cost in USD per dispatch (0 = don't change;
+            pass a negative number to clear the limit).
         model: Model override. Pass "none" to clear.
         permission_mode: Permission mode. Pass "none" to clear.
         allowed_tools: Comma-separated allowed tools. Pass "none" to clear.
@@ -781,13 +795,13 @@ async def update_agent(
         updated.append("permission_mode")
     if allowed_tools:
         if allowed_tools.lower() == "none":
-            agent.allowed_tools = []
+            agent.allowed_tools = None
         else:
             agent.allowed_tools = [t.strip() for t in allowed_tools.split(",") if t.strip()]
         updated.append("allowed_tools")
     if disallowed_tools:
         if disallowed_tools.lower() == "none":
-            agent.disallowed_tools = []
+            agent.disallowed_tools = None
         else:
             agent.disallowed_tools = [
                 t.strip() for t in disallowed_tools.split(",") if t.strip()

{agent_dispatch-0.2.0 → agent_dispatch-0.2.1}/tests/test_cli.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import os
+import subprocess
 from pathlib import Path
 from unittest.mock import patch
 
@@ -11,6 +12,7 @@ from click.testing import CliRunner
 
 from agent_dispatch.cli import cli
 from agent_dispatch.config import load_config
+from agent_dispatch.models import DispatchResult
 
 
 @pytest.fixture(autouse=True)
@@ -201,3 +203,179 @@ class TestUpdate:
         runner.invoke(cli, ["update", "proj", "--max-budget", "0"])
         config = load_config()
         assert config.agents["proj"].max_budget_usd is None
+
+    def test_update_empty_string_clears_model(self, tmp_path: Path):
+        """B2: --model "" should clear to None, not store empty string."""
+        agent_dir = tmp_path / "proj"
+        agent_dir.mkdir()
+        runner.invoke(cli, [
+            "add", "proj", str(agent_dir), "-d", "Test", "--model", "sonnet",
+        ])
+        result = runner.invoke(cli, ["update", "proj", "--model", ""])
+        assert result.exit_code == 0
+        config = load_config()
+        assert config.agents["proj"].model is None
+
+    def test_update_empty_string_clears_permission_mode(self, tmp_path: Path):
+        """B2: --permission-mode "" should clear to None."""
+        agent_dir = tmp_path / "proj"
+        agent_dir.mkdir()
+        runner.invoke(cli, [
+            "add", "proj", str(agent_dir), "-d", "Test",
+            "--permission-mode", "bypassPermissions",
+        ])
+        result = runner.invoke(cli, ["update", "proj", "--permission-mode", ""])
+        assert result.exit_code == 0
+        config = load_config()
+        assert config.agents["proj"].permission_mode is None
+
+    def test_update_allowed_tools_empty_clears_to_none(self, tmp_path: Path):
+        """B1+B2: --allowed-tools "" clears to None (inherit defaults)."""
+        agent_dir = tmp_path / "proj"
+        agent_dir.mkdir()
+        runner.invoke(cli, [
+            "add", "proj", str(agent_dir), "-d", "Test",
+            "--allowed-tools", "Bash,Read",
+        ])
+        runner.invoke(cli, ["update", "proj", "--allowed-tools", ""])
+        config = load_config()
+        assert config.agents["proj"].allowed_tools is None
+
+
+class TestListUnreadable:
+    def test_list_unreadable_directory(self, tmp_path: Path):
+        """A4: is_dir() OSError should show UNREADABLE, not crash."""
+        agent_dir = tmp_path / "proj"
+        agent_dir.mkdir()
+        runner.invoke(cli, ["add", "proj", str(agent_dir), "-d", "Test"])
+
+        with patch(
+            "agent_dispatch.cli.Path.is_dir",
+            side_effect=PermissionError("access denied"),
+        ):
+            result = runner.invoke(cli, ["list"])
+        assert result.exit_code == 0
+        assert "UNREADABLE" in result.output
+
+
+class TestListMalformedConfig:
+    def test_list_handles_bad_yaml(self, _isolated_config: Path):
+        """A5: malformed YAML shows friendly error, not traceback."""
+        _isolated_config.parent.mkdir(parents=True, exist_ok=True)
+        _isolated_config.write_text("agents: [not a dict\n")  # invalid YAML
+        result = runner.invoke(cli, ["list"])
+        assert result.exit_code != 0
+        assert "not valid YAML" in result.output
+
+    def test_list_handles_bad_schema(self, _isolated_config: Path):
+        """A5: YAML that doesn't match schema shows friendly error."""
+        _isolated_config.parent.mkdir(parents=True, exist_ok=True)
+        _isolated_config.write_text("agents: 42\nsettings: {}\n")
+        result = runner.invoke(cli, ["list"])
+        assert result.exit_code != 0
+        assert "invalid schema" in result.output
+
+
+class TestInit:
+    def test_init_creates_config(self, _isolated_config: Path):
+        config_file = _isolated_config
+        assert not config_file.exists()
+        with (
+            patch("agent_dispatch.cli.shutil.which", return_value=None),
+        ):
+            result = runner.invoke(cli, ["init"])
+        assert result.exit_code == 0
+        assert "Created config" in result.output
+        assert config_file.exists()
+
+    def test_init_existing_config(self, _isolated_config: Path):
+        config_file = _isolated_config
+        config_file.parent.mkdir(parents=True, exist_ok=True)
+        config_file.write_text("agents: {}\n")
+        with patch("agent_dispatch.cli.shutil.which", return_value=None):
+            result = runner.invoke(cli, ["init"])
+        assert "already exists" in result.output
+
+    def test_init_claude_not_found(self, _isolated_config: Path):
+        with patch("agent_dispatch.cli.shutil.which", return_value=None):
+            result = runner.invoke(cli, ["init"])
+        assert result.exit_code == 0
+        assert "claude CLI not found" in result.output
+
+    def test_init_registers_mcp_server(self, _isolated_config: Path):
+        with (
+            patch("agent_dispatch.cli.shutil.which", side_effect=lambda x: f"/usr/bin/{x}"),
+            patch("agent_dispatch.cli.subprocess.run") as mock_run,
+        ):
+            mock_run.return_value = subprocess.CompletedProcess(
+                args=[], returncode=0, stdout="", stderr=""
+            )
+            result = runner.invoke(cli, ["init"])
+        assert "Registered MCP server" in result.output
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        assert "claude" in cmd[0]
+        assert "mcp" in cmd
+        assert "add-json" in cmd
+
+    def test_init_mcp_registration_fails(self, _isolated_config: Path):
+        with (
+            patch("agent_dispatch.cli.shutil.which", side_effect=lambda x: f"/usr/bin/{x}"),
+            patch("agent_dispatch.cli.subprocess.run") as mock_run,
+        ):
+            mock_run.return_value = subprocess.CompletedProcess(
+                args=[], returncode=1, stdout="", stderr="registration failed"
+            )
+            result = runner.invoke(cli, ["init"])
+        assert "Failed to register" in result.output
+
+
+class TestTestCommand:
+    def test_success(self, tmp_path: Path):
+        agent_dir = tmp_path / "proj"
+        agent_dir.mkdir()
+        runner.invoke(cli, ["add", "proj", str(agent_dir), "-d", "Test agent"])
+        with patch("agent_dispatch.runner.dispatch") as mock_dispatch:
+            mock_dispatch.return_value = DispatchResult(
+                agent="proj", success=True, result="This is a test project.",
+                cost_usd=0.01, num_turns=1,
+            )
+            result = runner.invoke(cli, ["test", "proj"])
+        assert result.exit_code == 0
+        assert "This is a test project" in result.output
+        assert "$0.0100" in result.output
+
+    def test_agent_not_found(self):
+        result = runner.invoke(cli, ["test", "nonexistent"])
+        assert result.exit_code != 0
+        assert "not found" in result.output
+
+    def test_permission_error_shows_diagnosis(self, tmp_path: Path):
+        agent_dir = tmp_path / "proj"
+        agent_dir.mkdir()
+        runner.invoke(cli, ["add", "proj", str(agent_dir), "-d", "Test"])
+        with patch("agent_dispatch.runner.dispatch") as mock_dispatch:
+            mock_dispatch.return_value = DispatchResult(
+                agent="proj", success=False, result="",
+                error="permission denied for tool Bash",
+                error_type="permission",
+            )
+            result = runner.invoke(cli, ["test", "proj"])
+        assert result.exit_code != 0
+        assert "Diagnosis: permission error" in result.output
+        assert "bypassPermissions" in result.output
+
+    def test_timeout_error_shows_diagnosis(self, tmp_path: Path):
+        agent_dir = tmp_path / "proj"
+        agent_dir.mkdir()
+        runner.invoke(cli, ["add", "proj", str(agent_dir), "-d", "Test"])
+        with patch("agent_dispatch.runner.dispatch") as mock_dispatch:
+            mock_dispatch.return_value = DispatchResult(
+                agent="proj", success=False, result="",
+                error="timed out after 300s",
+                error_type="timeout",
+            )
+            result = runner.invoke(cli, ["test", "proj"])
+        assert result.exit_code != 0
+        assert "Diagnosis: timeout" in result.output
+        assert "--timeout 600" in result.output

{agent_dispatch-0.2.0 → agent_dispatch-0.2.1}/tests/test_models.py

@@ -26,6 +26,14 @@ def test_agent_config_defaults():
     assert agent.description == ""
     assert agent.max_budget_usd is None
     assert agent.model is None
+    # None = inherit from settings (B1)
+    assert agent.allowed_tools is None
+    assert agent.disallowed_tools is None
+
+
+def test_agent_config_explicit_empty_tools():
+    """Empty list means 'explicitly no tools', distinct from None (inherit)."""
+    agent = AgentConfig(directory="/tmp", allowed_tools=[], disallowed_tools=[])
     assert agent.allowed_tools == []
     assert agent.disallowed_tools == []
 
@@ -106,6 +114,14 @@ class TestPermissionModeValidation:
     def test_empty_string_no_warning(self):
         assert check_permission_mode("") is None
 
+    def test_trims_whitespace(self):
+        """C1: ' bypassPermissions ' (trailing space) should be recognized as valid."""
+        assert check_permission_mode(" bypassPermissions ") is None
+        assert check_permission_mode("\tplan\n") is None
+
+    def test_whitespace_only_no_warning(self):
+        assert check_permission_mode("   ") is None
+
 
 def test_settings_default_permissions():
     s = Settings(

{agent_dispatch-0.2.0 → agent_dispatch-0.2.1}/tests/test_runner.py

@@ -63,6 +63,22 @@ class TestErrorClassification:
         assert "bypassPermissions" in hint
         assert "allowed-tools" in hint
 
+    def test_classify_error_handles_none(self):
+        """A1: don't crash on None input."""
+        assert _classify_error(None) == "cli_error"
+
+    def test_classify_error_handles_empty_string(self):
+        """A1: don't crash on empty string."""
+        assert _classify_error("") == "cli_error"
+
+    def test_classify_error_handles_dict(self):
+        """A1: don't crash on non-string (e.g. dict from malformed JSON)."""
+        assert _classify_error({"weird": "value"}) == "cli_error"
+
+    def test_classify_error_handles_integer(self):
+        """A1: don't crash on int."""
+        assert _classify_error(42) == "cli_error"
+
 
 class TestBuildPrompt:
     def test_task_only(self):
@@ -156,6 +172,15 @@ class TestBuildCommand:
         assert "Bash" in cmd
         assert "Read" in cmd
 
+    def test_explicit_empty_allowed_tools_overrides_default(self):
+        """B1: allowed_tools=[] means 'explicitly none', not 'inherit'."""
+        settings = Settings(default_allowed_tools=["Bash", "Read"])
+        agent = AgentConfig(directory="/tmp", allowed_tools=[])
+        cmd = _build_command("claude", "hello", agent, settings)
+        assert "--allowedTools" not in cmd
+        assert "Bash" not in cmd
+        assert "Read" not in cmd
+
     def test_agent_allowed_tools_overrides_default(self):
         settings = Settings(default_allowed_tools=["Bash", "Read"])
         agent = AgentConfig(directory="/tmp", allowed_tools=["Edit"])
@@ -242,6 +267,47 @@ class TestDispatch:
         assert result.success
         assert result.result == "Just plain text"
 
+    @patch("agent_dispatch.runner.shutil.which", return_value="/usr/bin/claude")
+    @patch("agent_dispatch.runner.subprocess.run")
+    def test_plain_text_fallback_failure_sets_error_type(self, mock_run, _which):
+        """A2: non-JSON stdout with non-zero exit should set error_type."""
+        mock_run.return_value = subprocess.CompletedProcess(
+            args=[], returncode=1, stdout="something broke", stderr=""
+        )
+        result = dispatch("test", "x", self.agent, self.settings)
+        assert not result.success
+        assert result.error_type == "cli_error"
+        assert "something broke" in result.error
+
+    @patch("agent_dispatch.runner.shutil.which", return_value="/usr/bin/claude")
+    @patch("agent_dispatch.runner.subprocess.run")
+    def test_is_error_true_with_empty_result(self, mock_run, _which):
+        """A3: is_error=true with empty/missing result should get a fallback error message."""
+        mock_run.return_value = subprocess.CompletedProcess(
+            args=[], returncode=0,
+            stdout=json.dumps({"is_error": True, "result": ""}),
+            stderr="",
+        )
+        result = dispatch("test", "x", self.agent, self.settings)
+        assert not result.success
+        assert result.error_type == "cli_error"
+        assert "no details" in result.error
+
+    @patch("agent_dispatch.runner.shutil.which", return_value="/usr/bin/claude")
+    @patch("agent_dispatch.runner.subprocess.run")
+    def test_is_error_true_with_none_result(self, mock_run, _which):
+        """A1+A3: is_error=true with result=null should not crash."""
+        mock_run.return_value = subprocess.CompletedProcess(
+            args=[], returncode=0,
+            stdout=json.dumps({"is_error": True, "result": None}),
+            stderr="",
+        )
+        result = dispatch("test", "x", self.agent, self.settings)
+        assert not result.success
+        assert result.error_type == "cli_error"
+        assert result.error  # non-empty fallback
+        assert result.result == ""  # coerced safely
+
     @patch("agent_dispatch.runner.shutil.which", return_value="/usr/bin/claude")
     @patch("agent_dispatch.runner.subprocess.run")
     def test_context_is_prepended(self, mock_run, _which):
@@ -469,3 +535,30 @@ class TestDispatchStream:
         result = dispatch_stream("test", "hello", self.agent, self.settings)
         assert not result.success
         assert "No result received" in result.error or result.error
+
+    @patch("agent_dispatch.runner.shutil.which", return_value="/usr/bin/claude")
+    @patch("agent_dispatch.runner.subprocess.Popen")
+    def test_popen_file_not_found_error_type(self, mock_popen, _which):
+        """B5: Popen FileNotFoundError maps to not_found."""
+        mock_popen.side_effect = FileNotFoundError("claude not found")
+        result = dispatch_stream("test", "hello", self.agent, self.settings)
+        assert not result.success
+        assert result.error_type == "not_found"
+
+    @patch("agent_dispatch.runner.shutil.which", return_value="/usr/bin/claude")
+    @patch("agent_dispatch.runner.subprocess.Popen")
+    def test_popen_permission_error_type(self, mock_popen, _which):
+        """B5: Popen PermissionError maps to permission."""
+        mock_popen.side_effect = PermissionError("not executable")
+        result = dispatch_stream("test", "hello", self.agent, self.settings)
+        assert not result.success
+        assert result.error_type == "permission"
+
+    @patch("agent_dispatch.runner.shutil.which", return_value="/usr/bin/claude")
+    @patch("agent_dispatch.runner.subprocess.Popen")
+    def test_popen_generic_os_error_type(self, mock_popen, _which):
+        """B5: Popen generic OSError maps to cli_error."""
+        mock_popen.side_effect = OSError("disk full")
+        result = dispatch_stream("test", "hello", self.agent, self.settings)
+        assert not result.success
+        assert result.error_type == "cli_error"

{agent_dispatch-0.2.0 → agent_dispatch-0.2.1}/tests/test_server.py

@@ -147,6 +147,32 @@ class TestDispatchParallel:
         assert results[0]["success"]
         assert not results[1]["success"]
 
+    @pytest.mark.asyncio
+    async def test_parallel_exception_has_error_type(self, tmp_path: Path):
+        """B4: when a dispatch raises (not returns failure), exception-path preserves error_type."""
+        config = _make_config(tmp_path)
+
+        def fake_dispatch(name, task, agent_config, settings, context=None, **kw):
+            if name == "db":
+                raise RuntimeError("boom")
+            return _ok_dispatch_result(name)
+
+        with (
+            patch.object(server, "_get_config", return_value=config),
+            patch("agent_dispatch.server.runner.dispatch", side_effect=fake_dispatch),
+        ):
+            dispatches = json.dumps([
+                {"agent": "infra", "task": "check"},
+                {"agent": "db", "task": "check"},
+            ])
+            raw = await server.dispatch_parallel(dispatches)
+            results = json.loads(raw)
+
+        assert results[0]["success"]
+        assert not results[1]["success"]
+        assert results[1]["error_type"] == "cli_error"
+        assert "boom" in results[1]["error"]
+
 
 class TestDispatchCaching:
     @pytest.mark.asyncio
@@ -755,7 +781,8 @@ class TestUpdateAgent:
             loaded = load_config(config_file)
             agent = loaded.agents["proj"]
             assert agent.permission_mode is None
-            assert agent.allowed_tools == []
+            # "none" sentinel clears to None (inherit defaults), not []
+            assert agent.allowed_tools is None
         finally:
             os.environ.pop("AGENT_DISPATCH_CONFIG", None)