@ngocsangairvds/vsaf 3.2.14 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/tests/unit/test_task_models.py

@@ -1,1796 +0,0 @@
-"""Unit tests for Dynamic Task Models (Phase 11).
-
-Tests for TaskStatus, TaskPriority enums and AuditTask, TaskQueue models
-for multi-agent orchestration.
-
-Reference: design.md Section 9 (Dynamic Task Orchestration)
-Reference: requirements.md Phase 11
-"""
-
-from __future__ import annotations
-
-import time
-
-import pytest
-from vds_audit_orchestrator.models.task import (
-    AuditTask,
-    TaskPriority,
-    TaskQueue,
-    TaskStatus,
-)
-
-# =============================================================================
-# TaskStatus Enum Tests
-# =============================================================================
-
-
-class TestTaskStatus:
-    """Tests for TaskStatus enum."""
-
-    def test_all_status_values_exist(self) -> None:
-        """Verify all required status values are defined."""
-        assert TaskStatus.PENDING.value == "pending"
-        assert TaskStatus.RUNNING.value == "running"
-        assert TaskStatus.COMPLETED.value == "completed"
-        assert TaskStatus.FAILED.value == "failed"
-        assert TaskStatus.BLOCKED.value == "blocked"
-        assert TaskStatus.SKIPPED.value == "skipped"
-
-    def test_status_is_string_enum(self) -> None:
-        """Verify TaskStatus inherits from str for JSON serialization."""
-        assert isinstance(TaskStatus.PENDING, str)
-        assert TaskStatus.PENDING == "pending"
-
-    def test_status_count(self) -> None:
-        """Verify correct number of status values."""
-        assert len(TaskStatus) == 6
-
-    def test_status_comparison(self) -> None:
-        """Test TaskStatus values can be compared as strings."""
-        assert TaskStatus.PENDING == "pending"
-        assert TaskStatus.RUNNING != "pending"
-
-    def test_status_iteration(self) -> None:
-        """Test we can iterate over all statuses."""
-        statuses = list(TaskStatus)
-        assert len(statuses) == 6
-        assert TaskStatus.PENDING in statuses
-        assert TaskStatus.COMPLETED in statuses
-
-    def test_status_from_value(self) -> None:
-        """Test creating status from string value."""
-        assert TaskStatus("pending") == TaskStatus.PENDING
-        assert TaskStatus("completed") == TaskStatus.COMPLETED
-
-    def test_invalid_status_raises_error(self) -> None:
-        """Test invalid status value raises ValueError."""
-        with pytest.raises(ValueError):
-            TaskStatus("invalid_status")
-
-
-# =============================================================================
-# TaskPriority Enum Tests
-# =============================================================================
-
-
-class TestTaskPriority:
-    """Tests for TaskPriority enum."""
-
-    def test_all_priority_values_exist(self) -> None:
-        """Verify all required priority values are defined."""
-        assert TaskPriority.CRITICAL.value == 10
-        assert TaskPriority.HIGH.value == 50
-        assert TaskPriority.NORMAL.value == 100
-        assert TaskPriority.LOW.value == 200
-        assert TaskPriority.BACKGROUND.value == 500
-
-    def test_priority_is_int_enum(self) -> None:
-        """Verify TaskPriority inherits from int."""
-        assert isinstance(TaskPriority.CRITICAL, int)
-        assert TaskPriority.CRITICAL == 10
-
-    def test_priority_count(self) -> None:
-        """Verify correct number of priority values."""
-        assert len(TaskPriority) == 5
-
-    def test_priority_ordering(self) -> None:
-        """Test priority ordering (lower value = higher priority)."""
-        assert TaskPriority.CRITICAL < TaskPriority.HIGH
-        assert TaskPriority.HIGH < TaskPriority.NORMAL
-        assert TaskPriority.NORMAL < TaskPriority.LOW
-        assert TaskPriority.LOW < TaskPriority.BACKGROUND
-
-    def test_priority_comparison(self) -> None:
-        """Test TaskPriority values can be compared as integers."""
-        assert TaskPriority.CRITICAL < TaskPriority.NORMAL
-        assert TaskPriority.BACKGROUND > TaskPriority.HIGH
-
-    def test_priority_arithmetic(self) -> None:
-        """Test TaskPriority values support arithmetic operations."""
-        assert TaskPriority.CRITICAL + 40 == TaskPriority.HIGH
-        assert TaskPriority.NORMAL - TaskPriority.HIGH == 50
-
-    def test_priority_from_value(self) -> None:
-        """Test creating priority from int value."""
-        assert TaskPriority(10) == TaskPriority.CRITICAL
-        assert TaskPriority(100) == TaskPriority.NORMAL
-
-    def test_invalid_priority_raises_error(self) -> None:
-        """Test invalid priority value raises ValueError."""
-        with pytest.raises(ValueError):
-            TaskPriority(999)
-
-
-# =============================================================================
-# AuditTask Model Tests
-# =============================================================================
-
-
-class TestAuditTaskCreation:
-    """Tests for AuditTask model creation and defaults."""
-
-    def test_create_task_with_required_fields(self) -> None:
-        """Test creating task with only required fields."""
-        task = AuditTask(
-            type="code_analysis",
-            description="Analyze code quality",
-            assignee="CodeAnalysisAgent",
-        )
-        assert task.type == "code_analysis"
-        assert task.description == "Analyze code quality"
-        assert task.assignee == "CodeAnalysisAgent"
-
-    def test_task_has_auto_generated_id(self) -> None:
-        """Test task ID is auto-generated if not provided."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.id is not None
-        assert task.id.startswith("task-")
-        assert len(task.id) == 13  # "task-" + 8 hex chars
-
-    def test_task_with_custom_id(self) -> None:
-        """Test task can be created with custom ID."""
-        task = AuditTask(
-            id="custom-task-001",
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.id == "custom-task-001"
-
-    def test_task_default_status_is_pending(self) -> None:
-        """Test default status is PENDING."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.status == TaskStatus.PENDING
-
-    def test_task_default_priority_is_normal(self) -> None:
-        """Test default priority is NORMAL (100)."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.priority == TaskPriority.NORMAL.value
-
-    def test_task_default_dependencies_empty(self) -> None:
-        """Test default dependencies is empty list."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.dependencies == []
-
-    def test_task_default_input_data_empty(self) -> None:
-        """Test default input_data is empty dict."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.input_data == {}
-
-    def test_task_default_output_data_none(self) -> None:
-        """Test default output_data is None."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.output_data is None
-
-    def test_task_default_error_none(self) -> None:
-        """Test default error is None."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.error is None
-
-    def test_task_created_at_is_set(self) -> None:
-        """Test created_at is set to current time."""
-        before = time.time()
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        after = time.time()
-        assert before <= task.created_at <= after
-
-    def test_task_timestamps_initially_none(self) -> None:
-        """Test started_at and completed_at are initially None."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.started_at is None
-        assert task.completed_at is None
-
-    def test_task_default_created_by_system(self) -> None:
-        """Test default created_by is 'system'."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.created_by == "system"
-
-    def test_task_default_tags_empty(self) -> None:
-        """Test default tags is empty list."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.tags == []
-
-    def test_task_default_retry_count_zero(self) -> None:
-        """Test default retry_count is 0."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.retry_count == 0
-
-    def test_task_default_max_retries_three(self) -> None:
-        """Test default max_retries is 3."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        assert task.max_retries == 3
-
-    def test_task_with_all_fields(self) -> None:
-        """Test creating task with all fields specified."""
-        task = AuditTask(
-            id="full-task-001",
-            type="security_scan",
-            description="Full security scan",
-            assignee="SecurityAgent",
-            status=TaskStatus.PENDING,
-            dependencies=["dep-001", "dep-002"],
-            priority=TaskPriority.HIGH.value,
-            input_data={"target": "src/main.py"},
-            created_by="OrchestratorAgent",
-            tags=["security", "scan"],
-            max_retries=5,
-        )
-        assert task.id == "full-task-001"
-        assert task.type == "security_scan"
-        assert task.dependencies == ["dep-001", "dep-002"]
-        assert task.priority == 50
-        assert task.input_data == {"target": "src/main.py"}
-        assert task.created_by == "OrchestratorAgent"
-        assert task.tags == ["security", "scan"]
-        assert task.max_retries == 5
-
-    def test_task_priority_validation_min(self) -> None:
-        """Test priority must be >= 1."""
-        with pytest.raises(ValueError):
-            AuditTask(
-                type="test_task",
-                description="Test",
-                assignee="Agent",
-                priority=0,
-            )
-
-    def test_task_priority_validation_max(self) -> None:
-        """Test priority must be <= 1000."""
-        with pytest.raises(ValueError):
-            AuditTask(
-                type="test_task",
-                description="Test",
-                assignee="Agent",
-                priority=1001,
-            )
-
-
-# =============================================================================
-# AuditTask Computed Properties Tests
-# =============================================================================
-
-
-class TestAuditTaskComputedProperties:
-    """Tests for AuditTask computed properties."""
-
-    @pytest.fixture
-    def pending_task(self) -> AuditTask:
-        """Create a pending task for testing."""
-        return AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-
-    @pytest.fixture
-    def pending_task_with_deps(self) -> AuditTask:
-        """Create a pending task with dependencies."""
-        return AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-            dependencies=["dep-001", "dep-002"],
-        )
-
-    @pytest.fixture
-    def running_task(self) -> AuditTask:
-        """Create a running task for testing."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        task.start()
-        return task
-
-    @pytest.fixture
-    def completed_task(self) -> AuditTask:
-        """Create a completed task for testing."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        task.start()
-        task.complete({"result": "success"})
-        return task
-
-    @pytest.fixture
-    def failed_task(self) -> AuditTask:
-        """Create a failed task for testing."""
-        task = AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-        task.start()
-        task.fail("Something went wrong")
-        return task
-
-    # is_runnable tests
-    def test_is_runnable_pending_no_deps(self, pending_task: AuditTask) -> None:
-        """Test is_runnable is True for pending task without dependencies."""
-        assert pending_task.is_runnable is True
-
-    def test_is_runnable_pending_with_deps(self, pending_task_with_deps: AuditTask) -> None:
-        """Test is_runnable is False for pending task with dependencies."""
-        assert pending_task_with_deps.is_runnable is False
-
-    def test_is_runnable_running(self, running_task: AuditTask) -> None:
-        """Test is_runnable is False for running task."""
-        assert running_task.is_runnable is False
-
-    def test_is_runnable_completed(self, completed_task: AuditTask) -> None:
-        """Test is_runnable is False for completed task."""
-        assert completed_task.is_runnable is False
-
-    def test_is_runnable_failed(self, failed_task: AuditTask) -> None:
-        """Test is_runnable is False for failed task."""
-        assert failed_task.is_runnable is False
-
-    # is_terminal tests
-    def test_is_terminal_pending(self, pending_task: AuditTask) -> None:
-        """Test is_terminal is False for pending task."""
-        assert pending_task.is_terminal is False
-
-    def test_is_terminal_running(self, running_task: AuditTask) -> None:
-        """Test is_terminal is False for running task."""
-        assert running_task.is_terminal is False
-
-    def test_is_terminal_completed(self, completed_task: AuditTask) -> None:
-        """Test is_terminal is True for completed task."""
-        assert completed_task.is_terminal is True
-
-    def test_is_terminal_failed(self, failed_task: AuditTask) -> None:
-        """Test is_terminal is True for failed task."""
-        assert failed_task.is_terminal is True
-
-    def test_is_terminal_skipped(self) -> None:
-        """Test is_terminal is True for skipped task."""
-        task = AuditTask(
-            type="test_task",
-            description="Test",
-            assignee="Agent",
-        )
-        task.skip("Not applicable")
-        assert task.is_terminal is True
-
-    def test_is_terminal_blocked(self) -> None:
-        """Test is_terminal is False for blocked task."""
-        task = AuditTask(
-            type="test_task",
-            description="Test",
-            assignee="Agent",
-        )
-        task.block(["blocker-001"])
-        assert task.is_terminal is False
-
-    # duration_seconds tests
-    def test_duration_seconds_not_started(self, pending_task: AuditTask) -> None:
-        """Test duration_seconds is None for unstarted task."""
-        assert pending_task.duration_seconds is None
-
-    def test_duration_seconds_running(self, running_task: AuditTask) -> None:
-        """Test duration_seconds is calculated for running task."""
-        time.sleep(0.01)  # Small delay
-        duration = running_task.duration_seconds
-        assert duration is not None
-        assert duration >= 0.01
-
-    def test_duration_seconds_completed(self, completed_task: AuditTask) -> None:
-        """Test duration_seconds is calculated for completed task."""
-        duration = completed_task.duration_seconds
-        assert duration is not None
-        assert duration >= 0
-
-    def test_duration_seconds_precision(self) -> None:
-        """Test duration_seconds has millisecond precision (3 decimal places)."""
-        task = AuditTask(
-            type="test_task",
-            description="Test",
-            assignee="Agent",
-        )
-        task.start()
-        time.sleep(0.0123)  # ~12.3ms
-        task.complete()
-        duration = task.duration_seconds
-        assert duration is not None
-        # Check it's rounded to 3 decimal places
-        assert duration == round(duration, 3)
-
-    # can_retry tests
-    def test_can_retry_pending(self, pending_task: AuditTask) -> None:
-        """Test can_retry is False for pending task."""
-        assert pending_task.can_retry is False
-
-    def test_can_retry_running(self, running_task: AuditTask) -> None:
-        """Test can_retry is False for running task."""
-        assert running_task.can_retry is False
-
-    def test_can_retry_completed(self, completed_task: AuditTask) -> None:
-        """Test can_retry is False for completed task."""
-        assert completed_task.can_retry is False
-
-    def test_can_retry_failed_with_retries_left(self, failed_task: AuditTask) -> None:
-        """Test can_retry is True for failed task with retries remaining."""
-        assert failed_task.retry_count == 0
-        assert failed_task.max_retries == 3
-        assert failed_task.can_retry is True
-
-    def test_can_retry_failed_max_retries_reached(self) -> None:
-        """Test can_retry is False when max retries reached."""
-        task = AuditTask(
-            type="test_task",
-            description="Test",
-            assignee="Agent",
-            max_retries=2,
-        )
-        task.start()
-        task.fail("Error 1")
-        assert task.can_retry is True
-
-        task.retry()
-        task.start()
-        task.fail("Error 2")
-        assert task.can_retry is True
-
-        task.retry()
-        task.start()
-        task.fail("Error 3")
-        assert task.can_retry is False
-
-
-# =============================================================================
-# AuditTask State Transition Tests
-# =============================================================================
-
-
-class TestAuditTaskStateTransitions:
-    """Tests for AuditTask state transition methods."""
-
-    @pytest.fixture
-    def fresh_task(self) -> AuditTask:
-        """Create a fresh task for testing state transitions."""
-        return AuditTask(
-            type="test_task",
-            description="Test description",
-            assignee="TestAgent",
-        )
-
-    # start() tests
-    def test_start_from_pending(self, fresh_task: AuditTask) -> None:
-        """Test starting a pending task."""
-        before = time.time()
-        fresh_task.start()
-        after = time.time()
-
-        assert fresh_task.status == TaskStatus.RUNNING
-        assert fresh_task.started_at is not None
-        assert before <= fresh_task.started_at <= after
-
-    def test_start_from_running_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test starting an already running task raises ValueError."""
-        fresh_task.start()
-        with pytest.raises(ValueError, match="Cannot start task in running status"):
-            fresh_task.start()
-
-    def test_start_from_completed_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test starting a completed task raises ValueError."""
-        fresh_task.start()
-        fresh_task.complete()
-        with pytest.raises(ValueError, match="Cannot start task in completed status"):
-            fresh_task.start()
-
-    def test_start_from_failed_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test starting a failed task raises ValueError."""
-        fresh_task.start()
-        fresh_task.fail("Error")
-        with pytest.raises(ValueError, match="Cannot start task in failed status"):
-            fresh_task.start()
-
-    def test_start_from_blocked_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test starting a blocked task raises ValueError."""
-        fresh_task.block(["blocker"])
-        with pytest.raises(ValueError, match="Cannot start task in blocked status"):
-            fresh_task.start()
-
-    def test_start_from_skipped_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test starting a skipped task raises ValueError."""
-        fresh_task.skip()
-        with pytest.raises(ValueError, match="Cannot start task in skipped status"):
-            fresh_task.start()
-
-    # complete() tests
-    def test_complete_from_running(self, fresh_task: AuditTask) -> None:
-        """Test completing a running task."""
-        fresh_task.start()
-        before = time.time()
-        fresh_task.complete()
-        after = time.time()
-
-        assert fresh_task.status == TaskStatus.COMPLETED
-        assert fresh_task.completed_at is not None
-        assert before <= fresh_task.completed_at <= after
-
-    def test_complete_with_output(self, fresh_task: AuditTask) -> None:
-        """Test completing a task with output data."""
-        fresh_task.start()
-        output = {"findings": ["issue1", "issue2"], "score": 85}
-        fresh_task.complete(output)
-
-        assert fresh_task.status == TaskStatus.COMPLETED
-        assert fresh_task.output_data == output
-
-    def test_complete_without_output(self, fresh_task: AuditTask) -> None:
-        """Test completing a task without output data."""
-        fresh_task.start()
-        fresh_task.complete()
-
-        assert fresh_task.status == TaskStatus.COMPLETED
-        assert fresh_task.output_data is None
-
-    def test_complete_from_pending_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test completing a pending task raises ValueError."""
-        with pytest.raises(ValueError, match="Cannot complete task in pending status"):
-            fresh_task.complete()
-
-    def test_complete_from_completed_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test completing an already completed task raises ValueError."""
-        fresh_task.start()
-        fresh_task.complete()
-        with pytest.raises(ValueError, match="Cannot complete task in completed status"):
-            fresh_task.complete()
-
-    def test_complete_from_failed_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test completing a failed task raises ValueError."""
-        fresh_task.start()
-        fresh_task.fail("Error")
-        with pytest.raises(ValueError, match="Cannot complete task in failed status"):
-            fresh_task.complete()
-
-    # fail() tests
-    def test_fail_from_running(self, fresh_task: AuditTask) -> None:
-        """Test failing a running task."""
-        fresh_task.start()
-        before = time.time()
-        fresh_task.fail("Connection timeout")
-        after = time.time()
-
-        assert fresh_task.status == TaskStatus.FAILED
-        assert fresh_task.completed_at is not None
-        assert before <= fresh_task.completed_at <= after
-        assert fresh_task.error == "Connection timeout"
-
-    def test_fail_from_pending_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test failing a pending task raises ValueError."""
-        with pytest.raises(ValueError, match="Cannot fail task in pending status"):
-            fresh_task.fail("Error")
-
-    def test_fail_from_completed_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test failing a completed task raises ValueError."""
-        fresh_task.start()
-        fresh_task.complete()
-        with pytest.raises(ValueError, match="Cannot fail task in completed status"):
-            fresh_task.fail("Error")
-
-    def test_fail_from_failed_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test failing an already failed task raises ValueError."""
-        fresh_task.start()
-        fresh_task.fail("Error 1")
-        with pytest.raises(ValueError, match="Cannot fail task in failed status"):
-            fresh_task.fail("Error 2")
-
-    # skip() tests
-    def test_skip_sets_status(self, fresh_task: AuditTask) -> None:
-        """Test skipping a task sets status to SKIPPED."""
-        fresh_task.skip()
-        assert fresh_task.status == TaskStatus.SKIPPED
-
-    def test_skip_sets_completed_at(self, fresh_task: AuditTask) -> None:
-        """Test skipping a task sets completed_at."""
-        before = time.time()
-        fresh_task.skip()
-        after = time.time()
-
-        assert fresh_task.completed_at is not None
-        assert before <= fresh_task.completed_at <= after
-
-    def test_skip_with_reason(self, fresh_task: AuditTask) -> None:
-        """Test skipping a task with a reason."""
-        fresh_task.skip("Not applicable for this project type")
-        assert fresh_task.error == "Skipped: Not applicable for this project type"
-
-    def test_skip_without_reason(self, fresh_task: AuditTask) -> None:
-        """Test skipping a task without a reason."""
-        fresh_task.skip()
-        assert fresh_task.error is None
-
-    def test_skip_from_any_status(self, fresh_task: AuditTask) -> None:
-        """Test skip can be called from any status (flexible)."""
-        # Skip from pending
-        task1 = AuditTask(type="t", description="d", assignee="a")
-        task1.skip()
-        assert task1.status == TaskStatus.SKIPPED
-
-        # Skip from running
-        task2 = AuditTask(type="t", description="d", assignee="a")
-        task2.start()
-        task2.skip()
-        assert task2.status == TaskStatus.SKIPPED
-
-    # block() tests
-    def test_block_sets_status(self, fresh_task: AuditTask) -> None:
-        """Test blocking a task sets status to BLOCKED."""
-        fresh_task.block(["blocker-001"])
-        assert fresh_task.status == TaskStatus.BLOCKED
-
-    def test_block_sets_dependencies(self, fresh_task: AuditTask) -> None:
-        """Test blocking a task sets dependencies."""
-        blockers = ["blocker-001", "blocker-002"]
-        fresh_task.block(blockers)
-        assert fresh_task.dependencies == blockers
-
-    def test_block_replaces_dependencies(self, fresh_task: AuditTask) -> None:
-        """Test blocking replaces existing dependencies."""
-        task = AuditTask(
-            type="test",
-            description="test",
-            assignee="Agent",
-            dependencies=["old-dep"],
-        )
-        task.block(["new-blocker"])
-        assert task.dependencies == ["new-blocker"]
-
-    # unblock() tests
-    def test_unblock_removes_dependency(self, fresh_task: AuditTask) -> None:
-        """Test unblocking removes the specified dependency."""
-        fresh_task.block(["blocker-001", "blocker-002"])
-        fresh_task.unblock("blocker-001")
-        assert fresh_task.dependencies == ["blocker-002"]
-
-    def test_unblock_last_dependency_changes_status(self, fresh_task: AuditTask) -> None:
-        """Test unblocking last dependency changes status to PENDING."""
-        fresh_task.block(["blocker-001"])
-        fresh_task.unblock("blocker-001")
-        assert fresh_task.dependencies == []
-        assert fresh_task.status == TaskStatus.PENDING
-
-    def test_unblock_not_last_dependency_keeps_blocked(self, fresh_task: AuditTask) -> None:
-        """Test unblocking non-last dependency keeps status BLOCKED."""
-        fresh_task.block(["blocker-001", "blocker-002"])
-        fresh_task.unblock("blocker-001")
-        assert fresh_task.status == TaskStatus.BLOCKED
-
-    def test_unblock_nonexistent_dependency(self, fresh_task: AuditTask) -> None:
-        """Test unblocking nonexistent dependency is a no-op."""
-        fresh_task.block(["blocker-001"])
-        fresh_task.unblock("nonexistent")
-        assert fresh_task.dependencies == ["blocker-001"]
-        assert fresh_task.status == TaskStatus.BLOCKED
-
-    def test_unblock_on_pending_task(self, fresh_task: AuditTask) -> None:
-        """Test unblocking on pending task (edge case)."""
-        fresh_task.dependencies = ["dep-001"]
-        fresh_task.unblock("dep-001")
-        assert fresh_task.dependencies == []
-        # Status stays PENDING (was never BLOCKED)
-        assert fresh_task.status == TaskStatus.PENDING
-
-    # retry() tests
-    def test_retry_resets_task(self, fresh_task: AuditTask) -> None:
-        """Test retry resets a failed task to pending."""
-        fresh_task.start()
-        fresh_task.fail("Error")
-        result = fresh_task.retry()
-
-        assert result is True
-        assert fresh_task.status == TaskStatus.PENDING
-        assert fresh_task.retry_count == 1
-        assert fresh_task.error is None
-        assert fresh_task.started_at is None
-        assert fresh_task.completed_at is None
-
-    def test_retry_increments_count(self, fresh_task: AuditTask) -> None:
-        """Test retry increments retry_count."""
-        for i in range(3):
-            fresh_task.start()
-            fresh_task.fail(f"Error {i}")
-            fresh_task.retry()
-            assert fresh_task.retry_count == i + 1
-
-    def test_retry_returns_false_when_max_reached(self) -> None:
-        """Test retry returns False when max retries reached."""
-        task = AuditTask(
-            type="test",
-            description="test",
-            assignee="Agent",
-            max_retries=1,
-        )
-        task.start()
-        task.fail("Error 1")
-        assert task.retry() is True
-
-        task.start()
-        task.fail("Error 2")
-        assert task.retry() is False
-
-    def test_retry_from_pending_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test retry from pending raises ValueError."""
-        with pytest.raises(ValueError, match="Cannot retry task in pending status"):
-            fresh_task.retry()
-
-    def test_retry_from_running_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test retry from running raises ValueError."""
-        fresh_task.start()
-        with pytest.raises(ValueError, match="Cannot retry task in running status"):
-            fresh_task.retry()
-
-    def test_retry_from_completed_raises_error(self, fresh_task: AuditTask) -> None:
-        """Test retry from completed raises ValueError."""
-        fresh_task.start()
-        fresh_task.complete()
-        with pytest.raises(ValueError, match="Cannot retry task in completed status"):
-            fresh_task.retry()
-
-
-# =============================================================================
-# AuditTask Serialization Tests
-# =============================================================================
-
-
-class TestAuditTaskSerialization:
-    """Tests for AuditTask serialization."""
-
-    def test_model_dump(self) -> None:
-        """Test task can be serialized to dict."""
-        task = AuditTask(
-            id="task-001",
-            type="code_analysis",
-            description="Analyze code",
-            assignee="CodeAgent",
-            priority=TaskPriority.HIGH.value,
-            tags=["code", "analysis"],
-        )
-        data = task.model_dump()
-
-        assert data["id"] == "task-001"
-        assert data["type"] == "code_analysis"
-        assert data["status"] == "pending"  # enum value
-        assert data["priority"] == 50
-        assert data["tags"] == ["code", "analysis"]
-        assert "is_runnable" in data
-        assert "is_terminal" in data
-
-    def test_model_dump_excludes_none(self) -> None:
-        """Test model_dump can exclude None values."""
-        task = AuditTask(
-            type="test",
-            description="test",
-            assignee="Agent",
-        )
-        data = task.model_dump(exclude_none=True)
-
-        assert "output_data" not in data
-        assert "error" not in data
-        assert "started_at" not in data
-        assert "completed_at" not in data
-
-    def test_json_serialization(self) -> None:
-        """Test task can be serialized to JSON."""
-        import json
-
-        task = AuditTask(
-            id="task-001",
-            type="code_analysis",
-            description="Analyze code",
-            assignee="CodeAgent",
-        )
-        json_str = task.model_dump_json()
-        parsed = json.loads(json_str)
-
-        assert parsed["id"] == "task-001"
-        assert parsed["type"] == "code_analysis"
-        assert parsed["status"] == "pending"
-
-
-# =============================================================================
-# TaskQueue Model Tests
-# =============================================================================
-
-
-class TestTaskQueueCreation:
-    """Tests for TaskQueue model creation."""
-
-    def test_create_empty_queue(self) -> None:
-        """Test creating an empty task queue."""
-        queue = TaskQueue()
-        assert queue.tasks == {}
-        assert queue.active_workers == {}
-
-    def test_queue_initial_counts(self) -> None:
-        """Test initial counts are zero."""
-        queue = TaskQueue()
-        assert queue.pending_count == 0
-        assert queue.running_count == 0
-        assert queue.completed_count == 0
-        assert queue.failed_count == 0
-
-
-class TestTaskQueueAddGetTask:
-    """Tests for TaskQueue add_task and get_task methods."""
-
-    @pytest.fixture
-    def queue(self) -> TaskQueue:
-        """Create an empty task queue."""
-        return TaskQueue()
-
-    @pytest.fixture
-    def sample_task(self) -> AuditTask:
-        """Create a sample task."""
-        return AuditTask(
-            id="task-001",
-            type="code_analysis",
-            description="Analyze code",
-            assignee="CodeAgent",
-        )
-
-    def test_add_task(self, queue: TaskQueue, sample_task: AuditTask) -> None:
-        """Test adding a task to the queue."""
-        task_id = queue.add_task(sample_task)
-        assert task_id == "task-001"
-        assert "task-001" in queue.tasks
-
-    def test_add_task_returns_id(self, queue: TaskQueue, sample_task: AuditTask) -> None:
-        """Test add_task returns the task ID."""
-        task_id = queue.add_task(sample_task)
-        assert task_id == sample_task.id
-
-    def test_add_duplicate_task_raises_error(self, queue: TaskQueue, sample_task: AuditTask) -> None:
-        """Test adding duplicate task raises ValueError."""
-        queue.add_task(sample_task)
-        with pytest.raises(ValueError, match="Task task-001 already exists"):
-            queue.add_task(sample_task)
-
-    def test_get_task_existing(self, queue: TaskQueue, sample_task: AuditTask) -> None:
-        """Test getting an existing task."""
-        queue.add_task(sample_task)
-        task = queue.get_task("task-001")
-        assert task is not None
-        assert task.id == "task-001"
-        assert task.type == "code_analysis"
-
-    def test_get_task_nonexistent(self, queue: TaskQueue) -> None:
-        """Test getting a nonexistent task returns None."""
-        task = queue.get_task("nonexistent")
-        assert task is None
-
-
-class TestTaskQueueRunnableTasks:
-    """Tests for TaskQueue get_runnable_tasks method."""
-
-    @pytest.fixture
-    def queue_with_tasks(self) -> TaskQueue:
-        """Create a queue with various tasks for testing."""
-        queue = TaskQueue()
-
-        # Task with no dependencies (runnable)
-        queue.add_task(
-            AuditTask(
-                id="task-001",
-                type="init",
-                description="Initialize",
-                assignee="Agent",
-                priority=TaskPriority.NORMAL.value,
-            )
-        )
-
-        # Task with dependency on task-001 (not runnable until 001 completes)
-        queue.add_task(
-            AuditTask(
-                id="task-002",
-                type="analyze",
-                description="Analyze",
-                assignee="Agent",
-                dependencies=["task-001"],
-                priority=TaskPriority.HIGH.value,
-            )
-        )
-
-        # Another task with no dependencies (runnable, higher priority)
-        queue.add_task(
-            AuditTask(
-                id="task-003",
-                type="scan",
-                description="Scan",
-                assignee="Agent",
-                priority=TaskPriority.CRITICAL.value,
-            )
-        )
-
-        return queue
-
-    def test_get_runnable_tasks_excludes_deps(self, queue_with_tasks: TaskQueue) -> None:
-        """Test get_runnable_tasks excludes tasks with unmet dependencies."""
-        runnable = queue_with_tasks.get_runnable_tasks()
-        runnable_ids = [t.id for t in runnable]
-
-        assert "task-001" in runnable_ids
-        assert "task-003" in runnable_ids
-        assert "task-002" not in runnable_ids
-
-    def test_get_runnable_tasks_sorted_by_priority(self, queue_with_tasks: TaskQueue) -> None:
-        """Test get_runnable_tasks returns tasks sorted by priority."""
-        runnable = queue_with_tasks.get_runnable_tasks()
-
-        # task-003 (CRITICAL=10) should come before task-001 (NORMAL=100)
-        assert runnable[0].id == "task-003"
-        assert runnable[1].id == "task-001"
-
-    def test_get_runnable_tasks_after_dependency_completes(self, queue_with_tasks: TaskQueue) -> None:
-        """Test task becomes runnable after dependency completes."""
-        # Initially task-002 is not runnable
-        runnable = queue_with_tasks.get_runnable_tasks()
-        assert "task-002" not in [t.id for t in runnable]
-
-        # Start and complete task-001 (must start before completing)
-        queue_with_tasks.assign_task("task-001", "Worker1")
-        queue_with_tasks.complete_task("task-001")
-
-        # Now task-002 should be runnable
-        runnable = queue_with_tasks.get_runnable_tasks()
-        assert "task-002" in [t.id for t in runnable]
-
-    def test_get_runnable_tasks_empty_queue(self) -> None:
-        """Test get_runnable_tasks on empty queue."""
-        queue = TaskQueue()
-        runnable = queue.get_runnable_tasks()
-        assert runnable == []
-
-    def test_get_runnable_tasks_excludes_running(self) -> None:
-        """Test get_runnable_tasks excludes running tasks."""
-        queue = TaskQueue()
-        task = AuditTask(
-            id="task-001",
-            type="test",
-            description="test",
-            assignee="Agent",
-        )
-        queue.add_task(task)
-
-        # Before starting
-        runnable = queue.get_runnable_tasks()
-        assert len(runnable) == 1
-
-        # Start the task
-        task.start()
-
-        # After starting
-        runnable = queue.get_runnable_tasks()
-        assert len(runnable) == 0
-
-
-class TestTaskQueueAssignTask:
-    """Tests for TaskQueue assign_task method."""
-
-    @pytest.fixture
-    def queue_with_runnable_task(self) -> TaskQueue:
-        """Create a queue with a runnable task."""
-        queue = TaskQueue()
-        queue.add_task(
-            AuditTask(
-                id="task-001",
-                type="test",
-                description="test",
-                assignee="Agent",
-            )
-        )
-        return queue
-
-    def test_assign_task_success(self, queue_with_runnable_task: TaskQueue) -> None:
-        """Test successfully assigning a task."""
-        result = queue_with_runnable_task.assign_task("task-001", "WorkerAgent")
-
-        assert result is True
-        task = queue_with_runnable_task.get_task("task-001")
-        assert task is not None
-        assert task.status == TaskStatus.RUNNING
-        assert queue_with_runnable_task.active_workers["WorkerAgent"] == "task-001"
-
-    def test_assign_task_nonexistent(self) -> None:
-        """Test assigning nonexistent task returns False."""
-        queue = TaskQueue()
-        result = queue.assign_task("nonexistent", "Agent")
-        assert result is False
-
-    def test_assign_task_not_runnable(self) -> None:
-        """Test assigning non-runnable task returns False."""
-        queue = TaskQueue()
-        task = AuditTask(
-            id="task-001",
-            type="test",
-            description="test",
-            assignee="Agent",
-            dependencies=["blocker"],
-        )
-        queue.add_task(task)
-
-        result = queue.assign_task("task-001", "WorkerAgent")
-        assert result is False
-
-    def test_assign_task_agent_already_busy(self, queue_with_runnable_task: TaskQueue) -> None:
-        """Test assigning to agent already working returns False."""
-        # Add another task
-        queue_with_runnable_task.add_task(
-            AuditTask(
-                id="task-002",
-                type="test",
-                description="test",
-                assignee="Agent",
-            )
-        )
-
-        # Assign first task
-        queue_with_runnable_task.assign_task("task-001", "WorkerAgent")
-
-        # Try to assign second task to same agent
-        result = queue_with_runnable_task.assign_task("task-002", "WorkerAgent")
-        assert result is False
-
-
-class TestTaskQueueCompleteTask:
-    """Tests for TaskQueue complete_task method."""
-
-    @pytest.fixture
-    def queue_with_chain(self) -> TaskQueue:
-        """Create a queue with task dependency chain."""
-        queue = TaskQueue()
-
-        queue.add_task(
-            AuditTask(
-                id="task-001",
-                type="first",
-                description="First task",
-                assignee="Agent",
-            )
-        )
-        queue.add_task(
-            AuditTask(
-                id="task-002",
-                type="second",
-                description="Second task",
-                assignee="Agent",
-                dependencies=["task-001"],
-            )
-        )
-        queue.add_task(
-            AuditTask(
-                id="task-003",
-                type="third",
-                description="Third task",
-                assignee="Agent",
-                dependencies=["task-001"],
-            )
-        )
-
-        # Start task-001
-        queue.assign_task("task-001", "Worker1")
-        return queue
-
-    def test_complete_task_success(self, queue_with_chain: TaskQueue) -> None:
-        """Test completing a task updates status."""
-        queue_with_chain.complete_task("task-001", {"result": "done"})
-
-        task = queue_with_chain.get_task("task-001")
-        assert task is not None
-        assert task.status == TaskStatus.COMPLETED
-        assert task.output_data == {"result": "done"}
-
-    def test_complete_task_removes_from_active_workers(self, queue_with_chain: TaskQueue) -> None:
-        """Test completing task removes agent from active_workers."""
-        assert "Worker1" in queue_with_chain.active_workers
-
-        queue_with_chain.complete_task("task-001")
-
-        assert "Worker1" not in queue_with_chain.active_workers
-
-    def test_complete_task_unblocks_dependents(self, queue_with_chain: TaskQueue) -> None:
-        """Test completing task unblocks dependent tasks."""
-        unblocked = queue_with_chain.complete_task("task-001")
-
-        # Both task-002 and task-003 depend on task-001
-        assert "task-002" in unblocked
-        assert "task-003" in unblocked
-
-        # They should now be runnable
-        task2 = queue_with_chain.get_task("task-002")
-        task3 = queue_with_chain.get_task("task-003")
-        assert task2 is not None
-        assert task3 is not None
-        assert task2.dependencies == []
-        assert task3.dependencies == []
-
-    def test_complete_task_nonexistent(self) -> None:
-        """Test completing nonexistent task returns empty list."""
-        queue = TaskQueue()
-        unblocked = queue.complete_task("nonexistent")
-        assert unblocked == []
-
-
-class TestTaskQueueFailTask:
-    """Tests for TaskQueue fail_task method."""
-
-    @pytest.fixture
-    def queue_with_running_task(self) -> TaskQueue:
-        """Create a queue with a running task."""
-        queue = TaskQueue()
-        task = AuditTask(
-            id="task-001",
-            type="test",
-            description="test",
-            assignee="Agent",
-        )
-        queue.add_task(task)
-        queue.assign_task("task-001", "Worker1")
-        return queue
-
-    def test_fail_task_success(self, queue_with_running_task: TaskQueue) -> None:
-        """Test failing a task updates status and error."""
-        can_retry = queue_with_running_task.fail_task("task-001", "Connection failed")
-
-        task = queue_with_running_task.get_task("task-001")
-        assert task is not None
-        assert task.status == TaskStatus.FAILED
-        assert task.error == "Connection failed"
-        assert can_retry is True
-
-    def test_fail_task_removes_from_active_workers(self, queue_with_running_task: TaskQueue) -> None:
-        """Test failing task removes agent from active_workers."""
-        assert "Worker1" in queue_with_running_task.active_workers
-
-        queue_with_running_task.fail_task("task-001", "Error")
-
-        assert "Worker1" not in queue_with_running_task.active_workers
-
-    def test_fail_task_returns_can_retry_status(self) -> None:
-        """Test fail_task returns correct can_retry status."""
-        queue = TaskQueue()
-        task = AuditTask(
-            id="task-001",
-            type="test",
-            description="test",
-            assignee="Agent",
-            max_retries=0,  # No retries allowed
-        )
-        queue.add_task(task)
-        queue.assign_task("task-001", "Worker1")
-
-        can_retry = queue.fail_task("task-001", "Error")
-        assert can_retry is False
-
-    def test_fail_task_nonexistent(self) -> None:
-        """Test failing nonexistent task returns False."""
-        queue = TaskQueue()
-        result = queue.fail_task("nonexistent", "Error")
-        assert result is False
-
-
-class TestTaskQueueSpawnSubtask:
-    """Tests for TaskQueue spawn_subtask method."""
-
-    @pytest.fixture
-    def queue_with_parent(self) -> TaskQueue:
-        """Create a queue with a parent task."""
-        queue = TaskQueue()
-        queue.add_task(
-            AuditTask(
-                id="parent-001",
-                type="analysis",
-                description="Main analysis",
-                assignee="MainAgent",
-                priority=TaskPriority.HIGH.value,
-                tags=["main", "analysis"],
-            )
-        )
-        return queue
-
-    def test_spawn_subtask_creates_task(self, queue_with_parent: TaskQueue) -> None:
-        """Test spawn_subtask creates a new task."""
-        subtask_id = queue_with_parent.spawn_subtask(
-            parent_id="parent-001",
-            task_type="detail_analysis",
-            description="Detailed analysis of module X",
-            assignee="DetailAgent",
-        )
-
-        assert subtask_id.startswith("task-")
-        subtask = queue_with_parent.get_task(subtask_id)
-        assert subtask is not None
-        assert subtask.type == "detail_analysis"
-        assert subtask.description == "Detailed analysis of module X"
-        assert subtask.assignee == "DetailAgent"
-
-    def test_spawn_subtask_inherits_priority(self, queue_with_parent: TaskQueue) -> None:
-        """Test subtask inherits parent priority by default."""
-        subtask_id = queue_with_parent.spawn_subtask(
-            parent_id="parent-001",
-            task_type="sub",
-            description="Subtask",
-            assignee="SubAgent",
-        )
-
-        subtask = queue_with_parent.get_task(subtask_id)
-        assert subtask is not None
-        assert subtask.priority == TaskPriority.HIGH.value
-
-    def test_spawn_subtask_custom_priority(self, queue_with_parent: TaskQueue) -> None:
-        """Test subtask can have custom priority."""
-        subtask_id = queue_with_parent.spawn_subtask(
-            parent_id="parent-001",
-            task_type="sub",
-            description="Subtask",
-            assignee="SubAgent",
-            priority=TaskPriority.CRITICAL.value,
-        )
-
-        subtask = queue_with_parent.get_task(subtask_id)
-        assert subtask is not None
-        assert subtask.priority == TaskPriority.CRITICAL.value
-
-    def test_spawn_subtask_sets_created_by(self, queue_with_parent: TaskQueue) -> None:
-        """Test subtask created_by is set to parent's assignee."""
-        subtask_id = queue_with_parent.spawn_subtask(
-            parent_id="parent-001",
-            task_type="sub",
-            description="Subtask",
-            assignee="SubAgent",
-        )
-
-        subtask = queue_with_parent.get_task(subtask_id)
-        assert subtask is not None
-        assert subtask.created_by == "MainAgent"
-
-    def test_spawn_subtask_inherits_tags_with_parent_ref(self, queue_with_parent: TaskQueue) -> None:
-        """Test subtask inherits parent tags and adds parent reference."""
-        subtask_id = queue_with_parent.spawn_subtask(
-            parent_id="parent-001",
-            task_type="sub",
-            description="Subtask",
-            assignee="SubAgent",
-        )
-
-        subtask = queue_with_parent.get_task(subtask_id)
-        assert subtask is not None
-        assert "main" in subtask.tags
-        assert "analysis" in subtask.tags
-        assert "parent:parent-001" in subtask.tags
-
-    def test_spawn_subtask_with_input_data(self, queue_with_parent: TaskQueue) -> None:
-        """Test subtask with custom input data."""
-        subtask_id = queue_with_parent.spawn_subtask(
-            parent_id="parent-001",
-            task_type="sub",
-            description="Subtask",
-            assignee="SubAgent",
-            input_data={"module": "src/main.py", "depth": 3},
-        )
-
-        subtask = queue_with_parent.get_task(subtask_id)
-        assert subtask is not None
-        assert subtask.input_data == {"module": "src/main.py", "depth": 3}
-
-    def test_spawn_subtask_nonexistent_parent(self) -> None:
-        """Test spawn_subtask with nonexistent parent raises ValueError."""
-        queue = TaskQueue()
-        with pytest.raises(ValueError, match="Parent task nonexistent not found"):
-            queue.spawn_subtask(
-                parent_id="nonexistent",
-                task_type="sub",
-                description="Subtask",
-                assignee="SubAgent",
-            )
-
-
-class TestTaskQueueComputedProperties:
-    """Tests for TaskQueue computed properties."""
-
-    @pytest.fixture
-    def queue_with_various_tasks(self) -> TaskQueue:
-        """Create a queue with tasks in various states."""
-        queue = TaskQueue()
-
-        # Pending tasks
-        queue.add_task(AuditTask(id="pending-1", type="t", description="d", assignee="a"))
-        queue.add_task(AuditTask(id="pending-2", type="t", description="d", assignee="a"))
-
-        # Running task
-        running = AuditTask(id="running-1", type="t", description="d", assignee="a")
-        queue.add_task(running)
-        running.start()
-
-        # Completed tasks
-        completed = AuditTask(id="completed-1", type="t", description="d", assignee="a")
-        queue.add_task(completed)
-        completed.start()
-        completed.complete()
-
-        # Failed task
-        failed = AuditTask(id="failed-1", type="t", description="d", assignee="a")
-        queue.add_task(failed)
-        failed.start()
-        failed.fail("Error")
-
-        # Skipped task
-        skipped = AuditTask(id="skipped-1", type="t", description="d", assignee="a")
-        queue.add_task(skipped)
-        skipped.skip()
-
-        return queue
-
-    def test_pending_count(self, queue_with_various_tasks: TaskQueue) -> None:
-        """Test pending_count returns correct count."""
-        assert queue_with_various_tasks.pending_count == 2
-
-    def test_running_count(self, queue_with_various_tasks: TaskQueue) -> None:
-        """Test running_count returns correct count."""
-        assert queue_with_various_tasks.running_count == 1
-
-    def test_completed_count(self, queue_with_various_tasks: TaskQueue) -> None:
-        """Test completed_count returns correct count."""
-        assert queue_with_various_tasks.completed_count == 1
-
-    def test_failed_count(self, queue_with_various_tasks: TaskQueue) -> None:
-        """Test failed_count returns correct count."""
-        assert queue_with_various_tasks.failed_count == 1
-
-    def test_is_complete_false(self, queue_with_various_tasks: TaskQueue) -> None:
-        """Test is_complete is False when non-terminal tasks exist."""
-        assert queue_with_various_tasks.is_complete is False
-
-    def test_is_complete_true(self) -> None:
-        """Test is_complete is True when all tasks are terminal."""
-        queue = TaskQueue()
-
-        completed = AuditTask(id="t1", type="t", description="d", assignee="a")
-        queue.add_task(completed)
-        completed.start()
-        completed.complete()
-
-        skipped = AuditTask(id="t2", type="t", description="d", assignee="a")
-        queue.add_task(skipped)
-        skipped.skip()
-
-        assert queue.is_complete is True
-
-    def test_is_complete_empty_queue(self) -> None:
-        """Test is_complete is True for empty queue."""
-        queue = TaskQueue()
-        assert queue.is_complete is True
-
-    def test_has_failures_true(self, queue_with_various_tasks: TaskQueue) -> None:
-        """Test has_failures is True when failed tasks without retries exist."""
-        # Set max_retries to 0 so can_retry is False
-        failed = queue_with_various_tasks.get_task("failed-1")
-        assert failed is not None
-        failed.max_retries = 0
-
-        assert queue_with_various_tasks.has_failures is True
-
-    def test_has_failures_false_can_retry(self) -> None:
-        """Test has_failures is False when failed task can retry."""
-        queue = TaskQueue()
-        task = AuditTask(
-            id="t1",
-            type="t",
-            description="d",
-            assignee="a",
-            max_retries=3,
-        )
-        queue.add_task(task)
-        task.start()
-        task.fail("Error")
-
-        # Task can retry, so has_failures should be False
-        assert task.can_retry is True
-        assert queue.has_failures is False
-
-    def test_has_failures_false_no_failures(self) -> None:
-        """Test has_failures is False when no tasks failed."""
-        queue = TaskQueue()
-        task = AuditTask(id="t1", type="t", description="d", assignee="a")
-        queue.add_task(task)
-        task.start()
-        task.complete()
-
-        assert queue.has_failures is False
-
-
-class TestTaskQueueHelperMethods:
-    """Tests for TaskQueue helper methods."""
-
-    @pytest.fixture
-    def populated_queue(self) -> TaskQueue:
-        """Create a queue with multiple tasks."""
-        queue = TaskQueue()
-
-        # Add tasks with different assignees and statuses
-        queue.add_task(
-            AuditTask(
-                id="t1",
-                type="analysis",
-                description="d",
-                assignee="AgentA",
-                status=TaskStatus.PENDING,
-            )
-        )
-        queue.add_task(
-            AuditTask(
-                id="t2",
-                type="scan",
-                description="d",
-                assignee="AgentA",
-                status=TaskStatus.PENDING,
-            )
-        )
-        queue.add_task(
-            AuditTask(
-                id="t3",
-                type="verify",
-                description="d",
-                assignee="AgentB",
-                status=TaskStatus.PENDING,
-            )
-        )
-
-        # Mark t2 as blocked
-        queue.get_task("t2").block(["blocker"])  # type: ignore[union-attr]
-
-        return queue
-
-    def test_get_blocked_tasks(self, populated_queue: TaskQueue) -> None:
-        """Test get_blocked_tasks returns blocked tasks."""
-        blocked = populated_queue.get_blocked_tasks()
-        assert len(blocked) == 1
-        assert blocked[0].id == "t2"
-
-    def test_get_tasks_by_status(self, populated_queue: TaskQueue) -> None:
-        """Test get_tasks_by_status filters correctly."""
-        pending = populated_queue.get_tasks_by_status(TaskStatus.PENDING)
-        blocked = populated_queue.get_tasks_by_status(TaskStatus.BLOCKED)
-
-        assert len(pending) == 2  # t1 and t3
-        assert len(blocked) == 1  # t2
-
-    def test_get_tasks_by_agent(self, populated_queue: TaskQueue) -> None:
-        """Test get_tasks_by_agent filters correctly."""
-        agent_a_tasks = populated_queue.get_tasks_by_agent("AgentA")
-        agent_b_tasks = populated_queue.get_tasks_by_agent("AgentB")
-        agent_c_tasks = populated_queue.get_tasks_by_agent("AgentC")
-
-        assert len(agent_a_tasks) == 2
-        assert len(agent_b_tasks) == 1
-        assert len(agent_c_tasks) == 0
-
-
-class TestTaskQueueSerialization:
-    """Tests for TaskQueue serialization."""
-
-    def test_model_dump(self) -> None:
-        """Test queue can be serialized to dict."""
-        queue = TaskQueue()
-        queue.add_task(AuditTask(id="t1", type="test", description="Test", assignee="Agent"))
-
-        data = queue.model_dump()
-
-        assert "tasks" in data
-        assert "active_workers" in data
-        assert "pending_count" in data
-        assert "is_complete" in data
-        assert "has_failures" in data
-        assert "t1" in data["tasks"]
-
-    def test_json_serialization(self) -> None:
-        """Test queue can be serialized to JSON."""
-        import json
-
-        queue = TaskQueue()
-        queue.add_task(AuditTask(id="t1", type="test", description="Test", assignee="Agent"))
-
-        json_str = queue.model_dump_json()
-        parsed = json.loads(json_str)
-
-        assert "tasks" in parsed
-        assert "t1" in parsed["tasks"]
-
-
-class TestTaskQueueIntegration:
-    """Integration tests for TaskQueue with complex workflows."""
-
-    def test_full_workflow_single_task(self) -> None:
-        """Test complete lifecycle of a single task."""
-        queue = TaskQueue()
-
-        # Add task
-        task = AuditTask(
-            id="task-001",
-            type="code_analysis",
-            description="Analyze code quality",
-            assignee="CodeAgent",
-            input_data={"path": "src/"},
-        )
-        queue.add_task(task)
-
-        # Verify initial state
-        assert queue.pending_count == 1
-        assert queue.is_complete is False
-
-        # Assign to worker
-        queue.assign_task("task-001", "Worker1")
-        assert queue.running_count == 1
-        assert "Worker1" in queue.active_workers
-
-        # Complete task
-        queue.complete_task("task-001", {"issues_found": 3})
-        assert queue.completed_count == 1
-        assert queue.is_complete is True
-        assert "Worker1" not in queue.active_workers
-
-    def test_dependency_chain_workflow(self) -> None:
-        """Test workflow with task dependencies."""
-        queue = TaskQueue()
-
-        # Create dependency chain: init -> analyze -> report
-        queue.add_task(AuditTask(id="init", type="init", description="Init", assignee="Agent"))
-        queue.add_task(
-            AuditTask(
-                id="analyze",
-                type="analyze",
-                description="Analyze",
-                assignee="Agent",
-                dependencies=["init"],
-            )
-        )
-        queue.add_task(
-            AuditTask(
-                id="report",
-                type="report",
-                description="Report",
-                assignee="Agent",
-                dependencies=["analyze"],
-            )
-        )
-
-        # Only init should be runnable
-        runnable = queue.get_runnable_tasks()
-        assert len(runnable) == 1
-        assert runnable[0].id == "init"
-
-        # Complete init
-        queue.assign_task("init", "W1")
-        queue.complete_task("init")
-
-        # Now analyze should be runnable
-        runnable = queue.get_runnable_tasks()
-        assert len(runnable) == 1
-        assert runnable[0].id == "analyze"
-
-        # Complete analyze
-        queue.assign_task("analyze", "W2")
-        queue.complete_task("analyze")
-
-        # Now report should be runnable
-        runnable = queue.get_runnable_tasks()
-        assert len(runnable) == 1
-        assert runnable[0].id == "report"
-
-    def test_parallel_tasks_workflow(self) -> None:
-        """Test workflow with parallel tasks."""
-        queue = TaskQueue()
-
-        # Create parallel structure: init -> (scan1 | scan2 | scan3) -> merge
-        queue.add_task(AuditTask(id="init", type="init", description="Init", assignee="Agent"))
-        queue.add_task(
-            AuditTask(
-                id="scan1",
-                type="scan",
-                description="Scan 1",
-                assignee="Agent",
-                dependencies=["init"],
-            )
-        )
-        queue.add_task(
-            AuditTask(
-                id="scan2",
-                type="scan",
-                description="Scan 2",
-                assignee="Agent",
-                dependencies=["init"],
-            )
-        )
-        queue.add_task(
-            AuditTask(
-                id="scan3",
-                type="scan",
-                description="Scan 3",
-                assignee="Agent",
-                dependencies=["init"],
-            )
-        )
-        queue.add_task(
-            AuditTask(
-                id="merge",
-                type="merge",
-                description="Merge",
-                assignee="Agent",
-                dependencies=["scan1", "scan2", "scan3"],
-            )
-        )
-
-        # Complete init
-        queue.assign_task("init", "W1")
-        unblocked = queue.complete_task("init")
-
-        # All scans should be unblocked
-        assert set(unblocked) == {"scan1", "scan2", "scan3"}
-
-        # Complete scans
-        queue.assign_task("scan1", "W1")
-        queue.complete_task("scan1")
-        queue.assign_task("scan2", "W2")
-        queue.complete_task("scan2")
-        queue.assign_task("scan3", "W3")
-        unblocked = queue.complete_task("scan3")
-
-        # Merge should now be runnable
-        assert "merge" in unblocked
-        runnable = queue.get_runnable_tasks()
-        assert runnable[0].id == "merge"
-
-    def test_retry_workflow(self) -> None:
-        """Test task retry workflow."""
-        queue = TaskQueue()
-
-        task = AuditTask(
-            id="flaky",
-            type="test",
-            description="Flaky task",
-            assignee="Agent",
-            max_retries=2,
-        )
-        queue.add_task(task)
-
-        # First attempt fails
-        queue.assign_task("flaky", "W1")
-        can_retry = queue.fail_task("flaky", "Timeout")
-        assert can_retry is True
-
-        # Retry
-        task.retry()
-        assert task.status == TaskStatus.PENDING
-        assert task.retry_count == 1
-
-        # Second attempt fails
-        queue.assign_task("flaky", "W1")
-        can_retry = queue.fail_task("flaky", "Timeout again")
-        assert can_retry is True
-
-        # Retry again
-        task.retry()
-        assert task.retry_count == 2
-
-        # Third attempt succeeds
-        queue.assign_task("flaky", "W1")
-        queue.complete_task("flaky", {"success": True})
-        assert task.status == TaskStatus.COMPLETED
-
-    def test_spawn_and_complete_subtasks(self) -> None:
-        """Test spawning and completing subtasks."""
-        queue = TaskQueue()
-
-        # Add parent task
-        queue.add_task(
-            AuditTask(
-                id="parent",
-                type="analysis",
-                description="Main analysis",
-                assignee="MainAgent",
-            )
-        )
-
-        # Spawn subtasks during execution
-        sub1_id = queue.spawn_subtask(
-            parent_id="parent",
-            task_type="detail",
-            description="Detail 1",
-            assignee="SubAgent",
-        )
-        sub2_id = queue.spawn_subtask(
-            parent_id="parent",
-            task_type="detail",
-            description="Detail 2",
-            assignee="SubAgent",
-        )
-
-        # Verify subtasks exist
-        assert queue.get_task(sub1_id) is not None
-        assert queue.get_task(sub2_id) is not None
-        assert len(queue.tasks) == 3
-
-        # Complete subtasks
-        queue.assign_task(sub1_id, "W1")
-        queue.complete_task(sub1_id)
-        queue.assign_task(sub2_id, "W2")
-        queue.complete_task(sub2_id)
-
-        assert queue.completed_count == 2