@ngocsangairvds/vsaf 3.2.16 → 4.0.0

package/tools/vds-scripts/vds_evolution/tests/integration/test_openspace_integration.py

@@ -1,1342 +0,0 @@
-"""Integration tests for OpenSpace integration module.
-
-Tests the OpenSpaceClient class and router integration methods.
-All external services (MCP server, SQLite) are mocked.
-
-FR-1: Isolated OpenSpace installation
-FR-3: Gate pipeline integration
-FR-8: Evolution audit trail
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from vds_evolution.openspace_integration import (
-    ALLOWED_VISIBILITY,
-    DEFAULT_CANDIDATE_LIMIT,
-    DEFAULT_MCP_HOST,
-    DEFAULT_MCP_PORT,
-    DEFAULT_MCP_TIMEOUT,
-    DEFAULT_OPENSPACE_WORKSPACE,
-    DEFAULT_SEARCH_SCOPE,
-    ENV_OPENSPACE_API_KEY,
-    ENV_OPENSPACE_HOST_SKILL_DIRS,
-    ENV_OPENSPACE_MCP_HOST,
-    ENV_OPENSPACE_MCP_PORT,
-    ENV_OPENSPACE_TRANSPORT,
-    ENV_OPENSPACE_WORKSPACE,
-    INITIAL_RETRY_DELAY,
-    MAX_RETRIES,
-    OPENSPACE_DB_DIRNAME,
-    OPENSPACE_DB_FILENAME,
-    RETRY_BACKOFF,
-    UPLOAD_META_FILENAME,
-    ExecutionAnalysis,
-    MCPClientError,
-    OpenSpaceClient,
-    OpenSpaceStats,
-    _call_mcp_tool,
-)
-
-# =============================================================================
-# Fixtures
-# =============================================================================
-
-
-@pytest.fixture
-def mock_mcp_response() -> dict[str, Any]:
-    """Mock MCP server response."""
-    return {
-        "result": {
-            "status": "success",
-            "response": "Task completed",
-            "evolved_skills": [
-                {
-                    "skill_dir": "/tmp/test-skill",
-                    "name": "test-skill",
-                    "origin": "derived",
-                    "change_summary": "Improved description",
-                    "upload_ready": True,
-                }
-            ],
-            "task_id": "task-001",
-            "execution_time": 1.5,
-            "skills_used": ["test-skill"],
-            "tool_summary": [],
-        }
-    }
-
-
-@pytest.fixture
-def mock_evolution_candidate_data() -> dict[str, Any]:
-    """Mock evolution candidate data from SQLite."""
-    return {
-        "task_id": "task-001",
-        "timestamp": "2026-04-20T12:00:00Z",
-        "task_completed": True,
-        "execution_note": "Task completed successfully",
-        "tool_issues": [],
-        "candidate_for_evolution": 1,
-        "evolution_processed_at": None,
-        "evolution_suggestions": json.dumps(
-            [
-                {
-                    "type": "fix",
-                    "target_skills": ["skill-001"],
-                    "category": "tool_guide",
-                    "direction": "Fix API endpoint",
-                }
-            ]
-        ),
-        "skill_judgments": json.dumps(
-            [
-                {
-                    "skill_id": "skill-001",
-                    "skill_applied": True,
-                    "note": "Skill was applied successfully",
-                }
-            ]
-        ),
-        "analyzed_by": "claude-3-opus",
-        "analyzed_at": "2026-04-20T12:01:00Z",
-    }
-
-
-@pytest.fixture
-def mock_stats_data() -> dict[str, Any]:
-    """Mock statistics data from SQLite."""
-    return {
-        "total_skills": 42,
-        "total_skills_all": 50,
-        "by_category": {
-            "tool_guide": 20,
-            "workflow": 15,
-            "reference": 7,
-        },
-        "by_origin": {
-            "imported": 30,
-            "captured": 8,
-            "derived": 5,
-            "fixed": 7,
-        },
-        "total_analyses": 100,
-        "evolution_candidates": 15,
-        "unprocessed_evolution_candidates": 10,
-        "sel": 200,
-        "app": 180,
-        "comp": 160,
-        "fb": 20,
-    }
-
-
-@pytest.fixture
-def mock_store_conn(mock_evolution_candidate_data):
-    """Mock SQLite connection for testing."""
-    mock_conn = MagicMock()
-
-    # Mock fetchone for simple queries
-    def mock_fetchone():
-        return {"cnt": 42}
-
-    # Mock fetchall for multi-row queries
-    def mock_fetchall():
-        return [dict(mock_evolution_candidate_data)]
-
-    # Setup mock cursor
-    mock_cursor = MagicMock()
-    mock_cursor.fetchone = mock_fetchone
-    mock_cursor.fetchall = mock_fetchall
-    mock_cursor.rowcount = 1
-
-    # Mock execute
-    def mock_execute(query, params=None):
-        return mock_cursor
-
-    mock_conn.execute = mock_execute
-    mock_conn.row_factory = None
-    mock_conn.close = MagicMock()
-    mock_conn.commit = MagicMock()
-
-    return mock_conn
-
-
-# =============================================================================
-# ExecutionAnalysis Tests (replaces EvolutionCandidate)
-# =============================================================================
-
-
-class TestExecutionAnalysis:
-    """Tests for ExecutionAnalysis dataclass."""
-
-    def test_from_dict_basic(self):
-        """Test basic dict-to-analysis conversion."""
-        data = {
-            "task_id": "task-001",
-            "timestamp": "2026-04-20T11:00:00Z",
-            "task_completed": True,
-            "execution_note": "Task completed",
-            "tool_issues": [],
-            "evolution_suggestions": json.dumps([{"type": "fix", "target_skills": ["skill-001"]}]),
-            "skill_judgments": json.dumps([{"skill_id": "skill-001", "skill_applied": True, "note": "Applied"}]),
-            "analyzed_by": "claude-3-opus",
-            "analyzed_at": "2026-04-20T12:00:00Z",
-            "evolution_processed_at": None,
-        }
-
-        analysis = ExecutionAnalysis.from_dict(data)
-
-        assert analysis.task_id == "task-001"
-        assert len(analysis.evolution_suggestions) == 1
-        assert analysis.task_completed is True
-        assert analysis.candidate_for_evolution is True
-        assert analysis.analyzed_by == "claude-3-opus"
-        assert len(analysis.skill_judgments) == 1
-        assert analysis.skill_judgments[0].skill_id == "skill-001"
-
-    def test_from_dict_minimal(self):
-        """Test dict-to-analysis with minimal data."""
-        data = {"task_id": "task-002"}
-        analysis = ExecutionAnalysis.from_dict(data)
-
-        assert analysis.task_id == "task-002"
-        assert analysis.skill_judgments == []
-        assert analysis.evolution_suggestions == []
-        assert analysis.task_completed is False
-        assert analysis.candidate_for_evolution is False
-        assert analysis.evolution_processed_at is None
-        assert analysis.analyzed_by == ""
-
-    def test_to_dict_roundtrip(self):
-        """Test dict -> analysis -> dict roundtrip."""
-        original_data = {
-            "task_id": "task-003",
-            "timestamp": "2026-04-20T10:00:00Z",
-            "task_completed": False,
-            "execution_note": "",
-            "tool_issues": [],
-            "evolution_suggestions": json.dumps([{"type": "derived", "target_skills": ["skill-003"]}]),
-            "skill_judgments": json.dumps([]),
-            "analyzed_by": "gpt-4",
-            "analyzed_at": "2026-04-20T11:00:00Z",
-            "evolution_processed_at": None,
-        }
-
-        analysis = ExecutionAnalysis.from_dict(original_data)
-        result = analysis.to_dict()
-
-        assert result["task_id"] == original_data["task_id"]
-        assert result["task_completed"] == original_data["task_completed"]
-        assert result["candidate_for_evolution"] == original_data.get("candidate_for_evolution", True)
-
-
-# =============================================================================
-# OpenSpaceStats Tests
-# =============================================================================
-
-
-class TestOpenSpaceStats:
-    """Tests for OpenSpaceStats dataclass."""
-
-    def test_from_dict_basic(self, mock_stats_data: dict[str, Any]):
-        """Test basic dict-to-stats conversion."""
-        stats = OpenSpaceStats.from_dict(mock_stats_data)
-
-        assert stats.total_skills == 42
-        assert stats.total_skills_all == 50
-        assert stats.by_category == {"tool_guide": 20, "workflow": 15, "reference": 7}
-        assert stats.by_origin == {"imported": 30, "captured": 8, "derived": 5, "fixed": 7}
-        assert stats.total_analyses == 100
-        assert stats.evolution_candidates == 15
-        assert stats.unprocessed_candidates == 10
-        assert stats.total_selections == 200
-        assert stats.total_applied == 180
-        assert stats.total_completions == 160
-        assert stats.total_fallbacks == 20
-
-    def test_from_dict_empty(self):
-        """Test conversion with empty dict."""
-        stats = OpenSpaceStats.from_dict({})
-
-        assert stats.total_skills == 0
-        assert stats.total_skills_all == 0
-        assert stats.by_category == {}
-        assert stats.by_origin == {}
-        assert stats.total_analyses == 0
-        assert stats.evolution_candidates == 0
-        assert stats.unprocessed_candidates == 0
-        assert stats.total_selections == 0
-        assert stats.total_applied == 0
-        assert stats.total_completions == 0
-        assert stats.total_fallbacks == 0
-
-    def test_active_count(self, mock_stats_data: dict[str, Any]):
-        """Test active_count property."""
-        stats = OpenSpaceStats.from_dict(mock_stats_data)
-        assert stats.active_count == 42
-
-    def test_processed_candidates(self, mock_stats_data: dict[str, Any]):
-        """Test processed_candidates property."""
-        stats = OpenSpaceStats.from_dict(mock_stats_data)
-        assert stats.processed_candidates == 5  # 15 - 10
-
-    def test_completion_rate(self, mock_stats_data: dict[str, Any]):
-        """Test completion_rate property."""
-        stats = OpenSpaceStats.from_dict(mock_stats_data)
-        # 160 completions / 200 selections = 0.8
-        assert stats.completion_rate == pytest.approx(0.8)
-
-    def test_completion_rate_no_selections(self):
-        """Test completion_rate with zero selections."""
-        stats = OpenSpaceStats(total_selections=0, total_completions=0)
-        assert stats.completion_rate == 0.0
-
-    def test_to_dict_roundtrip(self, mock_stats_data: dict[str, Any]):
-        """Test dict -> stats -> dict roundtrip."""
-        original = mock_stats_data.copy()
-        stats = OpenSpaceStats.from_dict(original)
-        result = stats.to_dict()
-
-        assert result["total_skills"] == original["total_skills"]
-        assert result["total_skills_all"] == original["total_skills_all"]
-        assert result["evolution_candidates"] == original["evolution_candidates"]
-        assert result["unprocessed_evolution_candidates"] == original["unprocessed_evolution_candidates"]
-        assert result["completion_rate"] == pytest.approx(original["comp"] / original["sel"] if original["sel"] else 0)
-
-
-# =============================================================================
-# MCPClientError Tests
-# =============================================================================
-
-
-class TestMCPClientError:
-    """Tests for MCPClientError exception."""
-
-    def test_basic_error(self):
-        """Test basic error construction."""
-        error = MCPClientError(tool_name="test_tool", error="Connection refused")
-
-        assert error.tool_name == "test_tool"
-        assert error.error == "Connection refused"
-        assert error.details == {}
-        assert "test_tool" in str(error)
-        assert "Connection refused" in str(error)
-
-    def test_error_with_details(self):
-        """Test error with extra details."""
-        details = {"status_code": 500, "body": "Internal Server Error"}
-        error = MCPClientError(
-            tool_name="execute_task",
-            error="Server error",
-            details=details,
-        )
-
-        assert error.tool_name == "execute_task"
-        assert error.details == details
-        assert "execute_task" in str(error)
-        assert "Server error" in str(error)
-
-
-# =============================================================================
-# OpenSpaceClient Tests
-# =============================================================================
-
-
-class TestOpenSpaceClientInit:
-    """Tests for OpenSpaceClient initialization."""
-
-    def test_default_init(self, monkeypatch):
-        """Test default initialization uses env vars and defaults."""
-        monkeypatch.setenv(ENV_OPENSPACE_WORKSPACE, "/tmp/test-workspace")
-        monkeypatch.setenv(ENV_OPENSPACE_MCP_PORT, "9999")
-        monkeypatch.setenv(ENV_OPENSPACE_MCP_HOST, "0.0.0.0")
-
-        client = OpenSpaceClient()
-
-        assert client._workspace_path == "/tmp/test-workspace"
-        assert client._mcp_port == 9999
-        assert client._mcp_host == "0.0.0.0"
-        assert client._transport == "stdio"
-        assert client._mcp_url == "http://0.0.0.0:9999/mcp"
-        assert client._initialized is False
-        assert client._db_path is None
-        assert client._store_conn is None
-
-    def test_default_init_uses_canonical_skill_dirs(self, monkeypatch):
-        """Test default init uses canonical skill dirs from OPENSPACE_HOST_SKILL_DIRS.
-
-        The evolution loop uses canonical skill dirs (vds-skills/skills) as the
-        primary source, not shadow dirs. The shadow is only for OpenSpace's
-        internal use when running as an MCP server.
-        """
-        for key in [
-            ENV_OPENSPACE_WORKSPACE,
-            ENV_OPENSPACE_MCP_PORT,
-            ENV_OPENSPACE_MCP_HOST,
-            ENV_OPENSPACE_TRANSPORT,
-            ENV_OPENSPACE_HOST_SKILL_DIRS,
-        ]:
-            monkeypatch.delenv(key, raising=False)
-
-        client = OpenSpaceClient()
-
-        # Default skill dirs come from OPENSPACE_HOST_SKILL_DIRS env var
-        # which is loaded from shared env and defaults to canonical path
-        assert client._workspace_path == DEFAULT_OPENSPACE_WORKSPACE
-        # Skill dirs should be set from env or canonical default
-        assert len(client._skill_dirs) >= 1
-        assert client._transport == "stdio"
-
-    def test_explicit_init(self):
-        """Test initialization with explicit parameters."""
-        client = OpenSpaceClient(
-            workspace_path="/custom/path",
-            mcp_port=8888,
-            mcp_host="localhost",
-            skill_dirs=["/skills/path1", "/skills/path2"],
-        )
-
-        assert client._workspace_path == "/custom/path"
-        assert client._mcp_port == 8888
-        assert client._mcp_host == "localhost"
-        assert client._transport == "stdio"
-        assert client._mcp_url == "http://localhost:8888/mcp"
-        assert client._skill_dirs == ["/skills/path1", "/skills/path2"]
-
-    def test_skill_dirs_from_env(self, monkeypatch):
-        """Test skill_dirs loaded from env var."""
-        monkeypatch.setenv(ENV_OPENSPACE_HOST_SKILL_DIRS, "/path1, /path2, /path3")
-
-        client = OpenSpaceClient()
-
-        assert client._skill_dirs == ["/path1", "/path2", "/path3"]
-
-    def test_loads_shared_vds_env(self, monkeypatch):
-        """Test shared VDS env is loaded before resolving defaults."""
-        for key in [ENV_OPENSPACE_WORKSPACE, ENV_OPENSPACE_HOST_SKILL_DIRS]:
-            monkeypatch.delenv(key, raising=False)
-
-        def fake_load_shared_env(*args, **kwargs):
-            monkeypatch.setenv(ENV_OPENSPACE_WORKSPACE, "/shared/workspace")
-            monkeypatch.setenv(ENV_OPENSPACE_HOST_SKILL_DIRS, "/shared/skills")
-            return {
-                ENV_OPENSPACE_WORKSPACE: "/shared/workspace",
-                ENV_OPENSPACE_HOST_SKILL_DIRS: "/shared/skills",
-            }
-
-        with patch("vds_evolution.openspace_integration.load_shared_env", side_effect=fake_load_shared_env):
-            client = OpenSpaceClient()
-
-        assert client._workspace_path == "/shared/workspace"
-        assert client._skill_dirs == ["/shared/skills"]
-
-    def test_skill_dirs_explicit_overrides_env(self, monkeypatch):
-        """Test explicit skill_dirs override env var."""
-        monkeypatch.setenv(ENV_OPENSPACE_HOST_SKILL_DIRS, "/env/path")
-
-        client = OpenSpaceClient(skill_dirs=["/explicit/path"])
-
-        assert client._skill_dirs == ["/explicit/path"]
-
-    def test_mcp_url_format(self):
-        """Test MCP URL format with default values."""
-        client = OpenSpaceClient()
-        assert client._mcp_url == f"http://{DEFAULT_MCP_HOST}:{DEFAULT_MCP_PORT}/mcp"
-
-    def test_transport_override(self):
-        """Test explicit transport selection."""
-        client = OpenSpaceClient(transport="sse")
-        assert client.get_transport() == "sse"
-        assert client._mcp_url == f"http://{DEFAULT_MCP_HOST}:{DEFAULT_MCP_PORT}/sse"
-
-
-class TestOpenSpaceClientLifecycle:
-    """Tests for OpenSpaceClient lifecycle methods."""
-
-    @patch.object(OpenSpaceClient, "_ensure_initialized")
-    def test_close_releases_connection(self, mock_init):
-        """Test close releases the SQLite connection."""
-        mock_conn = MagicMock()
-        client = OpenSpaceClient()
-        client._store_conn = mock_conn
-        client._initialized = True
-
-        client.close()
-
-        mock_conn.close.assert_called_once()
-        assert client._store_conn is None
-        assert client._initialized is False
-
-    @patch.object(OpenSpaceClient, "_ensure_initialized")
-    def test_close_on_none_connection(self, mock_init):
-        """Test close handles None connection gracefully."""
-        client = OpenSpaceClient()
-        client._store_conn = None
-        client._initialized = True
-
-        # Should not raise
-        client.close()
-        assert client._store_conn is None
-
-    @patch.object(OpenSpaceClient, "_ensure_initialized")
-    def test_close_multiple_times_safe(self, mock_init):
-        """Test close is idempotent."""
-        mock_conn = MagicMock()
-        client = OpenSpaceClient()
-        client._store_conn = mock_conn
-
-        client.close()
-        mock_conn.close.assert_called_once()
-
-        client.close()  # Second close
-        mock_conn.close.assert_called_once()  # Still only once
-
-    def test_is_ready_false_before_init(self):
-        """Test is_ready returns False before initialization."""
-        client = OpenSpaceClient()
-        assert client.is_ready() is False
-
-
-class TestOpenSpaceClientEnsureInitialized:
-    """Tests for _ensure_initialized method."""
-
-    def test_initializes_db_path(self, tmp_path, monkeypatch):
-        """Test that _ensure_initialized sets db_path."""
-        monkeypatch.setenv(ENV_OPENSPACE_WORKSPACE, str(tmp_path))
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_PORT, raising=False)
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_HOST, raising=False)
-
-        client = OpenSpaceClient()
-        client._ensure_initialized()
-
-        assert client._db_path is not None
-        assert client._db_path.exists()
-        assert client._db_path.name == "openspace.db"
-        assert str(tmp_path) in str(client._db_path)
-
-    @patch.object(OpenSpaceClient, "__init__", return_value=None)
-    def test_initialized_flag_set(self, mock_init):
-        """Test that _initialized flag is set."""
-        client = OpenSpaceClient.__new__(OpenSpaceClient)
-        client._workspace_path = "/tmp"
-        client._mcp_port = 8080
-        client._mcp_host = "localhost"
-        client._mcp_url = "http://localhost:8080/mcp"
-        client._transport = "stdio"
-        client._skill_dirs = []
-        client._db_path = None
-        client._store_conn = None
-        client._initialized = False
-
-        with patch.object(client, "_make_connection", return_value=MagicMock()):
-            client._ensure_initialized()
-
-        assert client._initialized is True
-
-    @patch.object(OpenSpaceClient, "_make_connection", return_value=MagicMock())
-    def test_connection_configured(self, mock_conn):
-        """Test that connection is configured with WAL mode."""
-        mock_conn_instance = MagicMock()
-
-        client = OpenSpaceClient.__new__(OpenSpaceClient)
-        client._workspace_path = "/tmp"
-        client._mcp_port = 8080
-        client._mcp_host = "localhost"
-        client._mcp_url = "http://localhost:8080/mcp"
-        client._transport = "stdio"
-        client._skill_dirs = []
-        client._db_path = Path("/tmp/.openspace/openspace.db")
-        client._store_conn = mock_conn_instance
-        client._initialized = False
-
-        client._ensure_initialized()
-
-        mock_conn.assert_called_once()
-
-    @patch.object(OpenSpaceClient, "__init__", return_value=None)
-    def test_no_double_init(self, mock_init):
-        """Test that multiple _ensure_initialized calls are safe."""
-        call_count = 0
-
-        def mock_make_connection(*args, **kwargs):
-            nonlocal call_count
-            call_count += 1
-            return MagicMock()
-
-        client = OpenSpaceClient.__new__(OpenSpaceClient)
-        client._workspace_path = "/tmp"
-        client._mcp_port = 8080
-        client._mcp_host = "localhost"
-        client._mcp_url = "http://localhost:8080/mcp"
-        client._transport = "stdio"
-        client._skill_dirs = []
-        client._db_path = None
-        client._store_conn = None
-        client._initialized = False
-
-        with patch.object(client, "_make_connection", side_effect=mock_make_connection):
-            client._ensure_initialized()
-            client._ensure_initialized()  # Second call
-
-        # _make_connection should only be called once
-        assert call_count == 1
-
-
-class TestOpenSpaceClientMCPTools:
-    """Tests for OpenSpaceClient MCP tool invocation methods."""
-
-    def test_execute_task_success(self, mock_mcp_response):
-        """Test execute_task with successful response."""
-        with patch(
-            "vds_evolution.openspace_integration._call_mcp_tool", return_value=mock_mcp_response["result"]
-        ) as mock_call:
-            client = OpenSpaceClient()
-            result = client.execute_task(
-                task="Test task",
-                search_scope="local",
-            )
-
-            mock_call.assert_called_once()
-            call_args = mock_call.call_args
-            assert call_args[1]["tool_name"] == "execute_task"
-            assert call_args[1]["arguments"]["task"] == "Test task"
-            assert call_args[1]["arguments"]["search_scope"] == "local"
-            assert result["status"] == "success"
-            assert len(result["evolved_skills"]) == 1
-
-    def test_execute_task_with_all_params(self):
-        """Test execute_task with all optional parameters."""
-        with patch(
-            "vds_evolution.openspace_integration._call_mcp_tool", return_value={"status": "success", "task_id": "t1"}
-        ) as mock_call:
-            client = OpenSpaceClient(
-                workspace_path="/custom",
-                skill_dirs=["/dir1", "/dir2"],
-            )
-            with patch.object(client, "_ensure_initialized"):
-                client.execute_task(
-                    task="Test",
-                    workspace_dir="/workspace",
-                    max_iterations=30,
-                    skill_dirs=["/override"],
-                    search_scope="all",
-                )
-
-            call_args = mock_call.call_args[1]
-            assert call_args["arguments"]["workspace_dir"] == "/workspace"
-            assert call_args["arguments"]["max_iterations"] == 30
-            assert call_args["arguments"]["skill_dirs"] == ["/override"]
-            assert call_args["arguments"]["search_scope"] == "all"
-
-    def test_execute_task_falls_back_to_env_skill_dirs(self):
-        """Test execute_task uses env skill_dirs when no explicit dirs."""
-        with patch(
-            "vds_evolution.openspace_integration._call_mcp_tool", return_value={"status": "success"}
-        ) as mock_call:
-            client = OpenSpaceClient(skill_dirs=["/env/path"])
-            client.execute_task(task="Test")
-
-            call_args = mock_call.call_args[1]["arguments"]
-            assert call_args["skill_dirs"] == ["/env/path"]
-
-    def test_search_skills(self, mock_mcp_response):
-        """Test search_skills invocation."""
-        with patch(
-            "vds_evolution.openspace_integration._call_mcp_tool", return_value={"results": [], "count": 0}
-        ) as mock_call:
-            client = OpenSpaceClient()
-            client.search_skills(
-                query="test query",
-                source="local",
-                limit=10,
-                auto_import=False,
-            )
-
-            call_args = mock_call.call_args[1]
-            assert call_args["tool_name"] == "search_skills"
-            assert call_args["arguments"]["query"] == "test query"
-            assert call_args["arguments"]["source"] == "local"
-            assert call_args["arguments"]["limit"] == 10
-            assert call_args["arguments"]["auto_import"] is False
-            assert call_args["timeout"] == 120
-
-    def test_fix_skill(self):
-        """Test fix_skill invocation."""
-        with patch(
-            "vds_evolution.openspace_integration._call_mcp_tool",
-            return_value={
-                "status": "success",
-                "new_skill": {
-                    "skill_dir": "/tmp/skill",
-                    "name": "test-skill",
-                    "origin": "fixed",
-                    "upload_ready": True,
-                },
-            },
-        ) as mock_call:
-            client = OpenSpaceClient()
-            result = client.fix_skill(
-                skill_dir="/tmp/test-skill",
-                direction="Fix the broken API call",
-            )
-
-            call_args = mock_call.call_args[1]
-            assert call_args["tool_name"] == "fix_skill"
-            assert call_args["arguments"]["skill_dir"] == "/tmp/test-skill"
-            assert call_args["arguments"]["direction"] == "Fix the broken API call"
-            assert call_args["timeout"] == 300
-            assert result["status"] == "success"
-
-    def test_upload_skill(self):
-        """Test upload_skill invocation."""
-        with patch(
-            "vds_evolution.openspace_integration._call_mcp_tool",
-            return_value={"status": "success", "skill_id": "skill-001"},
-        ) as mock_call:
-            client = OpenSpaceClient()
-            client.upload_skill(
-                skill_dir="/tmp/my-skill",
-                visibility="private",
-                origin="derived",
-                parent_skill_ids=["parent-001"],
-                tags=["tag1", "tag2"],
-                created_by="test-user",
-                change_summary="Improved documentation",
-            )
-
-            call_args = mock_call.call_args[1]
-            assert call_args["tool_name"] == "upload_skill"
-            assert call_args["arguments"]["skill_dir"] == "/tmp/my-skill"
-            assert call_args["arguments"]["visibility"] == "private"
-            assert call_args["arguments"]["origin"] == "derived"
-            assert call_args["arguments"]["parent_skill_ids"] == ["parent-001"]
-            assert call_args["arguments"]["tags"] == ["tag1", "tag2"]
-
-    def test_upload_skill_invalid_visibility(self):
-        """Test upload_skill rejects invalid visibility."""
-        client = OpenSpaceClient()
-
-        with pytest.raises(ValueError) as exc_info:
-            client.upload_skill(
-                skill_dir="/tmp/skill",
-                visibility="public-private",
-            )
-
-        assert "visibility must be one of" in str(exc_info.value)
-        assert "public-private" in str(exc_info.value)
-
-    def test_upload_skill_defaults(self):
-        """Test upload_skill only sends required fields."""
-        with patch(
-            "vds_evolution.openspace_integration._call_mcp_tool", return_value={"status": "success"}
-        ) as mock_call:
-            client = OpenSpaceClient()
-            client.upload_skill(skill_dir="/tmp/skill")
-
-            call_args = mock_call.call_args[1]
-            assert call_args["arguments"]["skill_dir"] == "/tmp/skill"
-            assert call_args["arguments"]["visibility"] == "public"  # default
-            assert "origin" not in call_args["arguments"]
-            assert "parent_skill_ids" not in call_args["arguments"]
-
-
-class TestOpenSpaceClientStoreAccess:
-    """Tests for OpenSpaceClient SQLite store access methods."""
-
-    def test_load_evolution_candidates(self, mock_store_conn, mock_evolution_candidate_data, monkeypatch):
-        """Test loading evolution candidates from SQLite."""
-        monkeypatch.setenv(ENV_OPENSPACE_WORKSPACE, "/tmp/test")
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_PORT, raising=False)
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_HOST, raising=False)
-
-        client = OpenSpaceClient()
-        client._store_conn = mock_store_conn
-        client._initialized = True
-
-        # Mock the row factory
-        mock_store_conn.row_factory = MagicMock()
-
-        mock_cursor = MagicMock()
-        mock_cursor.fetchall.return_value = [
-            {
-                **mock_evolution_candidate_data,
-                "sj_skill_id": "skill-001",
-                "skill_applied": 1,
-                "sj_note": "Skill was applied successfully",
-            }
-        ]
-
-        def mock_execute(query, params=None):
-            return mock_cursor
-
-        mock_store_conn.execute = mock_execute
-
-        candidates = client.load_evolution_candidates(limit=50, include_processed=False)
-
-        assert len(candidates) == 1
-        assert candidates[0].task_id == "task-001"
-        assert len(candidates[0].skill_ids) == 1
-        assert candidates[0].skill_ids[0] == "skill-001"
-        assert candidates[0].task_completed is True
-        assert candidates[0].evolution_processed_at is None
-
-    def test_load_evolution_candidates_empty(self, mock_store_conn, monkeypatch):
-        """Test loading candidates returns empty list when no data."""
-        monkeypatch.setenv(ENV_OPENSPACE_WORKSPACE, "/tmp/test")
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_PORT, raising=False)
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_HOST, raising=False)
-
-        client = OpenSpaceClient()
-        mock_cursor = MagicMock()
-        mock_cursor.fetchall.return_value = []
-
-        def mock_execute(query, params=None):
-            return mock_cursor
-
-        mock_store_conn.execute = mock_execute
-        client._store_conn = mock_store_conn
-        client._initialized = True
-
-        candidates = client.load_evolution_candidates()
-        assert candidates == []
-
-    def test_mark_evolution_processed(self, mock_store_conn, monkeypatch):
-        """Test marking evolution as processed."""
-        monkeypatch.setenv(ENV_OPENSPACE_WORKSPACE, "/tmp/test")
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_PORT, raising=False)
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_HOST, raising=False)
-
-        client = OpenSpaceClient()
-        mock_cursor = MagicMock()
-        mock_cursor.rowcount = 1
-
-        executed_queries = []
-
-        def mock_execute(query, params=None):
-            executed_queries.append((query, params))
-            return mock_cursor
-
-        mock_store_conn.execute = mock_execute
-        mock_store_conn.commit = MagicMock()
-        client._store_conn = mock_store_conn
-        client._initialized = True
-
-        result = client.mark_evolution_processed("task-999")
-
-        assert result is True
-        assert mock_store_conn.commit.called
-        assert len(executed_queries) == 1
-        query, params = executed_queries[0]
-        assert "UPDATE execution_analyses" in query
-        assert "SET evolution_processed_at" in query
-        assert params[1] == "task-999"
-        assert isinstance(params[0], str)
-        assert params[0]
-
-    def test_get_stats(self, mock_store_conn, mock_stats_data, monkeypatch):
-        """Test getting aggregate statistics."""
-        monkeypatch.setenv(ENV_OPENSPACE_WORKSPACE, "/tmp/test")
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_PORT, raising=False)
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_HOST, raising=False)
-
-        client = OpenSpaceClient()
-
-        query_results = {
-            "SELECT COUNT(*) FROM skill_records WHERE is_active=1": [(42,)],
-            "SELECT category, COUNT(*) AS cnt FROM skill_records WHERE is_active=1 GROUP BY category": [
-                {"category": "tool_guide", "cnt": 20},
-                {"category": "workflow", "cnt": 15},
-                {"category": "reference", "cnt": 7},
-            ],
-            "SELECT lineage_origin, COUNT(*) AS cnt FROM skill_records WHERE is_active=1 GROUP BY lineage_origin": [
-                {"lineage_origin": "imported", "cnt": 30},
-                {"lineage_origin": "captured", "cnt": 8},
-                {"lineage_origin": "derived", "cnt": 5},
-                {"lineage_origin": "fixed", "cnt": 7},
-            ],
-            "SELECT COUNT(*) FROM execution_analyses": [(100,)],
-            "SELECT COUNT(*) FROM execution_analyses WHERE candidate_for_evolution = 1": [(15,)],
-            "SELECT COUNT(*) FROM execution_analyses WHERE candidate_for_evolution = 1 AND evolution_processed_at IS NULL": [
-                (10,)
-            ],
-            "SELECT SUM(total_selections) AS sel, SUM(total_applied) AS app, SUM(total_completions) AS comp, SUM(total_fallbacks) AS fb FROM skill_records WHERE is_active=1": [
-                {"sel": 200, "app": 180, "comp": 160, "fb": 20}
-            ],
-            "SELECT COUNT(*) FROM skill_records": [(50,)],
-        }
-
-        def mock_execute(query, params=None):
-            normalized = " ".join(query.split())
-            rows = query_results[normalized]
-            cursor = MagicMock()
-            cursor.fetchone.return_value = rows[0] if rows else None
-            cursor.__iter__.return_value = iter(rows)
-            return cursor
-
-        mock_store_conn.execute = mock_execute
-        client._store_conn = mock_store_conn
-        client._initialized = True
-
-        stats = client.get_stats()
-
-        assert isinstance(stats, OpenSpaceStats)
-        assert stats.total_skills == 42
-        assert stats.total_skills_all == 50
-        assert stats.evolution_candidates == 15
-        assert stats.unprocessed_candidates == 10
-
-    def test_get_store_returns_connection(self, mock_store_conn, monkeypatch):
-        """Test get_store returns the SQLite connection."""
-        monkeypatch.setenv(ENV_OPENSPACE_WORKSPACE, "/tmp/test")
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_PORT, raising=False)
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_HOST, raising=False)
-
-        client = OpenSpaceClient()
-        client._store_conn = mock_store_conn
-        client._initialized = True
-
-        conn = client.get_store()
-        assert conn is mock_store_conn
-
-    def test_get_db_path(self, monkeypatch):
-        """Test get_db_path returns the database path."""
-        monkeypatch.setenv(ENV_OPENSPACE_WORKSPACE, "/tmp/test")
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_PORT, raising=False)
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_HOST, raising=False)
-
-        client = OpenSpaceClient()
-        client._db_path = Path("/tmp/.openspace/openspace.db")
-
-        path = client.get_db_path()
-        assert path == Path("/tmp/.openspace/openspace.db")
-
-    def test_get_db_path_not_initialized(self):
-        """Test get_db_path returns None before initialization."""
-        client = OpenSpaceClient()
-        assert client.get_db_path() is None
-
-    def test_repr(self):
-        """Test string representation."""
-        client = OpenSpaceClient(
-            workspace_path="/test",
-            mcp_port=8888,
-        )
-        repr_str = repr(client)
-        assert "OpenSpaceClient" in repr_str
-        assert "/test" in repr_str
-        assert "8888" in repr_str
-        assert "initialized=False" in repr_str
-
-
-class TestOpenSpaceClientErrorHandling:
-    """Tests for error handling in OpenSpaceClient."""
-
-    def test_execute_task_propagates_mcp_error(self):
-        """Test that MCP errors propagate correctly."""
-        with patch(
-            "vds_evolution.openspace_integration._call_mcp_tool",
-            side_effect=MCPClientError(
-                tool_name="execute_task",
-                error="Connection timeout",
-                details={"status_code": 504},
-            ),
-        ):
-            client = OpenSpaceClient()
-
-            with pytest.raises(MCPClientError) as exc_info:
-                client.execute_task(task="Test")
-
-            assert exc_info.value.tool_name == "execute_task"
-            assert exc_info.value.error == "Connection timeout"
-
-    def test_load_evolution_candidates_handles_error(self, monkeypatch):
-        """Test load_evolution_candidates handles store errors."""
-        monkeypatch.setenv(ENV_OPENSPACE_WORKSPACE, "/tmp/test")
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_PORT, raising=False)
-        monkeypatch.delenv(ENV_OPENSPACE_MCP_HOST, raising=False)
-
-        client = OpenSpaceClient()
-        client._store_conn = None
-        client._initialized = True
-
-        # Should raise RuntimeError when conn is None
-        with pytest.raises(RuntimeError):
-            client.load_evolution_candidates()
-
-
-# =============================================================================
-# MCP Client Helper Tests
-# =============================================================================
-
-
-class TestCallMcpTool:
-    """Tests for the _call_mcp_tool helper function."""
-
-    def test_stdio_dispatch(self):
-        """Test stdio transport dispatch."""
-        with patch("vds_evolution.openspace_integration._resolve_transport", return_value="stdio"), patch(
-            "vds_evolution.openspace_integration._call_mcp_tool_stdio",
-            return_value={"status": "ok"},
-        ) as mock_stdio:
-            result = _call_mcp_tool(tool_name="test_tool", arguments={"key": "value"})
-
-        assert result == {"status": "ok"}
-        mock_stdio.assert_called_once_with("test_tool", {"key": "value"}, timeout=DEFAULT_MCP_TIMEOUT)
-
-    def test_successful_call(self, mock_mcp_response):
-        """Test successful MCP tool call."""
-        with patch("vds_evolution.openspace_integration._resolve_transport", return_value="streamable-http"):
-            with patch("vds_evolution.openspace_integration.httpx") as mock_httpx:
-                mock_client = MagicMock()
-                mock_response = MagicMock()
-                mock_response.json.return_value = mock_mcp_response
-                mock_response.raise_for_status = MagicMock()
-                mock_client.__enter__ = MagicMock(return_value=mock_client)
-                mock_client.__exit__ = MagicMock(return_value=None)
-                mock_client.post.return_value = mock_response
-                mock_httpx.Client.return_value = mock_client
-
-                result = _call_mcp_tool(
-                    tool_name="test_tool",
-                    arguments={"key": "value"},
-                    mcp_url="http://localhost:8080/mcp",
-                )
-
-            assert result == mock_mcp_response["result"]
-            mock_client.post.assert_called_once()
-            call_args = mock_client.post.call_args
-            assert call_args[1]["json"]["method"] == "tools/call"
-            assert call_args[1]["json"]["params"]["name"] == "test_tool"
-
-    def test_error_response_raises(self):
-        """Test that error responses raise MCPClientError."""
-        with patch("vds_evolution.openspace_integration._resolve_transport", return_value="streamable-http"):
-            with patch("vds_evolution.openspace_integration.httpx") as mock_httpx:
-                mock_client = MagicMock()
-                mock_response = MagicMock()
-                mock_response.json.return_value = {
-                    "error": {
-                        "message": "Tool not found",
-                        "code": -32601,
-                    }
-                }
-                mock_response.raise_for_status = MagicMock()
-                mock_client.__enter__ = MagicMock(return_value=mock_client)
-                mock_client.__exit__ = MagicMock(return_value=None)
-                mock_client.post.return_value = mock_response
-                mock_httpx.Client.return_value = mock_client
-
-                with pytest.raises(MCPClientError) as exc_info:
-                    _call_mcp_tool(
-                        tool_name="missing_tool",
-                        arguments={},
-                        mcp_url="http://localhost:8080/mcp",
-                    )
-
-            assert exc_info.value.tool_name == "missing_tool"
-            assert "Tool not found" in str(exc_info.value)
-
-    def test_http_error_raises(self):
-        """Test that HTTP errors raise MCPClientError."""
-        with patch("vds_evolution.openspace_integration._resolve_transport", return_value="streamable-http"):
-            with patch("vds_evolution.openspace_integration.httpx") as mock_httpx:
-                mock_client = MagicMock()
-                mock_response = MagicMock()
-                mock_response.raise_for_status.side_effect = Exception("500 Internal Server Error")
-                mock_client.__enter__ = MagicMock(return_value=mock_client)
-                mock_client.__exit__ = MagicMock(return_value=None)
-                mock_client.post.return_value = mock_response
-                mock_httpx.Client.return_value = mock_client
-
-                with pytest.raises(MCPClientError) as exc_info:
-                    _call_mcp_tool(
-                        tool_name="test",
-                        arguments={},
-                        mcp_url="http://localhost:8080/mcp",
-                    )
-
-            assert exc_info.value.tool_name == "test"
-
-    def test_retry_on_failure(self):
-        """Test that retries occur on transient failures."""
-        with patch("vds_evolution.openspace_integration._resolve_transport", return_value="streamable-http"):
-            with patch("vds_evolution.openspace_integration.httpx") as mock_httpx:
-                mock_client = MagicMock()
-
-                # Fail twice, succeed on third attempt
-                call_count = 0
-
-                def mock_post(*args, **kwargs):
-                    nonlocal call_count
-                    call_count += 1
-                    mock_response = MagicMock()
-                    if call_count < 3:
-                        mock_response.raise_for_status.side_effect = Exception("Timeout")
-                    else:
-                        mock_response.json.return_value = {"result": {"status": "ok"}}
-                        mock_response.raise_for_status = MagicMock()
-                    return mock_response
-
-                mock_client.__enter__ = MagicMock(return_value=mock_client)
-                mock_client.__exit__ = MagicMock(return_value=None)
-                mock_client.post = mock_post
-                mock_httpx.Client.return_value = mock_client
-
-                result = _call_mcp_tool(
-                    tool_name="test",
-                    arguments={},
-                    mcp_url="http://localhost:8080/mcp",
-                )
-
-            assert call_count == 3
-            assert result == {"status": "ok"}
-
-
-# =============================================================================
-# TestConstants
-# =============================================================================
-
-
-class TestConstants:
-    """Tests for module-level constants."""
-
-    def test_default_mcp_port(self):
-        """Test DEFAULT_MCP_PORT constant."""
-        assert DEFAULT_MCP_PORT == 8080
-
-    def test_default_mcp_host(self):
-        """Test DEFAULT_MCP_HOST constant."""
-        assert DEFAULT_MCP_HOST == "127.0.0.1"
-
-    def test_default_mcp_timeout(self):
-        """Test DEFAULT_MCP_TIMEOUT constant."""
-        assert DEFAULT_MCP_TIMEOUT == 600
-
-    def test_default_candidate_limit(self):
-        """Test DEFAULT_CANDIDATE_LIMIT constant."""
-        assert DEFAULT_CANDIDATE_LIMIT == 50
-
-    def test_default_search_scope(self):
-        """Test DEFAULT_SEARCH_SCOPE constant."""
-        assert DEFAULT_SEARCH_SCOPE == "local"
-
-    def test_allowed_visibility(self):
-        """Test ALLOWED_VISIBILITY tuple."""
-        assert ALLOWED_VISIBILITY == ("public", "private")
-
-    def test_upload_meta_filename(self):
-        """Test UPLOAD_META_FILENAME."""
-        assert UPLOAD_META_FILENAME == ".upload_meta.json"
-
-    def test_retry_config(self):
-        """Test retry configuration."""
-        assert MAX_RETRIES == 5
-        assert INITIAL_RETRY_DELAY == 0.1
-        assert RETRY_BACKOFF == 2.0
-
-    def test_env_var_names(self):
-        """Test environment variable name constants."""
-        assert ENV_OPENSPACE_WORKSPACE == "OPENSPACE_WORKSPACE"
-        assert ENV_OPENSPACE_HOST_SKILL_DIRS == "OPENSPACE_HOST_SKILL_DIRS"
-        assert ENV_OPENSPACE_API_KEY == "OPENSPACE_API_KEY"
-        assert ENV_OPENSPACE_MCP_PORT == "OPENSPACE_MCP_PORT"
-        assert ENV_OPENSPACE_MCP_HOST == "OPENSPACE_MCP_HOST"
-        assert ENV_OPENSPACE_TRANSPORT == "OPENSPACE_TRANSPORT"
-
-    def test_openpace_db_filenames(self):
-        """Test OpenSpace database filenames."""
-        assert OPENSPACE_DB_FILENAME == "openspace.db"
-        assert OPENSPACE_DB_DIRNAME == ".openspace"
-
-
-class TestTransportEndpoints:
-    """Tests for SSE and streamable-http transport endpoint resolution."""
-
-    def test_sse_endpoint_url(self):
-        """Test that SSE transport targets /sse endpoint."""
-        from vds_evolution.openspace_integration import _get_mcp_url
-
-        url = _get_mcp_url("sse", host="localhost", port=8080)
-        assert url == "http://localhost:8080/sse"
-
-    def test_streamable_http_endpoint_url(self):
-        """Test that streamable-http transport targets /mcp endpoint."""
-        from vds_evolution.openspace_integration import _get_mcp_url
-
-        url = _get_mcp_url("streamable-http", host="localhost", port=8080)
-        assert url == "http://localhost:8080/mcp"
-
-    def test_stdio_uses_subprocess(self):
-        """Test that stdio transport uses subprocess invocation."""
-        from vds_evolution.openspace_integration import _get_mcp_command
-
-        # When openspace-mcp is in PATH, returns a command list
-        _get_mcp_command()
-        # The function may return None or empty list if not installed
-        # Just verify the function exists and is callable
-        assert callable(_get_mcp_command)
-
-    def test_transport_resolution_from_env(self, monkeypatch):
-        """Test transport resolution from OPENSPACE_TRANSPORT env var."""
-        from vds_evolution.openspace_integration import _resolve_transport
-
-        monkeypatch.setenv("OPENSPACE_TRANSPORT", "sse")
-        transport = _resolve_transport()
-        assert transport == "sse"
-
-        monkeypatch.setenv("OPENSPACE_TRANSPORT", "streamable-http")
-        transport = _resolve_transport()
-        assert transport == "streamable-http"
-
-        monkeypatch.setenv("OPENSPACE_TRANSPORT", "stdio")
-        transport = _resolve_transport()
-        assert transport == "stdio"
-
-    def test_transport_resolution_default(self, monkeypatch):
-        """Test transport defaults to stdio when not set."""
-        from vds_evolution.openspace_integration import _resolve_transport
-
-        monkeypatch.delenv("OPENSPACE_TRANSPORT", raising=False)
-        transport = _resolve_transport()
-        assert transport == "stdio"
-
-    def test_transport_invalid_value_raises(self, monkeypatch):
-        """Test invalid transport values raise an error."""
-        from vds_evolution.openspace_integration import OpenSpaceTransportError, _resolve_transport
-
-        monkeypatch.setenv("OPENSPACE_TRANSPORT", "invalid-transport")
-        with pytest.raises(OpenSpaceTransportError):
-            _resolve_transport()
-
-
-class TestLocalModelJudge:
-    """Tests for LocalModelJudge in ensemble_judge module."""
-
-    def test_local_judge_initialization(self):
-        """Test LocalModelJudge can be instantiated."""
-        from vds_evolution.gates.ensemble_judge import LocalModelJudge
-
-        judge = LocalModelJudge(
-            base_url="http://localhost:11434",
-            model_id="llama3.2:latest",
-        )
-        assert judge.base_url == "http://localhost:11434"
-        assert judge.model_id == "llama3.2:latest"
-
-    def test_local_judge_protocol_compliance(self):
-        """Test LocalModelJudge implements Judge protocol."""
-        from typing import Protocol
-
-        from vds_evolution.gates.ensemble_judge import LocalModelJudge
-
-        assert issubclass(LocalModelJudge, Protocol) or hasattr(LocalModelJudge, "evaluate")
-        # Verify it has the required method
-        judge = LocalModelJudge()
-        assert hasattr(judge, "evaluate")
-
-    @pytest.mark.asyncio
-    async def test_local_judge_connection_failure(self):
-        """Test LocalModelJudge handles connection failures gracefully."""
-        from vds_evolution.gates.ensemble_judge import JudgeResult, LocalModelJudge
-
-        judge = LocalModelJudge(base_url="http://localhost:9999", model_id="test")
-        vote = await judge.evaluate(
-            skill_name="test-skill",
-            old_content="old",
-            new_content="new",
-            prompt="Evaluate",
-        )
-
-        # Should return abstain or error on connection failure
-        assert vote.result in [JudgeResult.ABSTAIN, JudgeResult.ERROR]
-
-
-class TestHmacBinding:
-    """Tests for HMAC verdict binding."""
-
-    def test_hmac_signature_creation(self):
-        """Test HMAC signature can be created for verdict."""
-        from vds_evolution.hmac_binding import HmacSignature, sign_verdict
-
-        verdict = {"skill": "test-skill", "verdict": "pass"}
-        sig = sign_verdict(verdict)
-
-        assert isinstance(sig, HmacSignature)
-        assert len(sig.signature) == 64  # SHA256 hex
-        assert sig.algorithm == "HMAC-SHA256"
-        assert sig.key_id == "default"
-
-    def test_hmac_payload_hash_deterministic(self):
-        """Test HMAC payload hash is deterministic."""
-        from vds_evolution.hmac_binding import sign_verdict
-
-        verdict = {"a": 1, "b": 2}
-        sig1 = sign_verdict(verdict)
-        sig2 = sign_verdict(verdict)
-
-        assert sig1.payload_hash == sig2.payload_hash
-
-    def test_hmac_sign_and_attach(self):
-        """Test sign_and_attach adds signature to verdict."""
-        from vds_evolution.hmac_binding import sign_and_attach
-
-        verdict = {"skill": "test"}
-        signed = sign_and_attach(verdict)
-
-        assert "_signature" in signed
-        assert "signature" in signed["_signature"]
-        assert "payload_hash" in signed["_signature"]
-
-    def test_hmac_compute_hash_order_independent(self):
-        """Test _compute_hash is order-independent."""
-        from vds_evolution.hmac_binding import _compute_hash
-
-        hash1 = _compute_hash({"a": 1, "b": 2})
-        hash2 = _compute_hash({"b": 2, "a": 1})
-
-        assert hash1 == hash2
-
-
-class TestAutoPromoteDaemon:
-    """Tests for auto-promote daemon."""
-
-    def test_daemon_initialization(self):
-        """Test AutoPromoteDaemon can be initialized."""
-        from vds_evolution.auto_promote import AutoPromoteConfig, AutoPromoteDaemon
-
-        config = AutoPromoteConfig(poll_interval=30.0, dry_run=True)
-        daemon = AutoPromoteDaemon(config)
-
-        assert daemon.config.poll_interval == 30.0
-        assert daemon.config.dry_run is True
-
-    def test_config_defaults(self):
-        """Test AutoPromoteConfig has sensible defaults."""
-        from vds_evolution.auto_promote import AutoPromoteConfig
-
-        config = AutoPromoteConfig()
-
-        assert config.poll_interval == 60.0
-        assert config.max_failures == 3
-        assert config.backoff_multiplier == 2.0
-        assert config.max_backoff == 600.0
-        assert config.dry_run is False
-
-    def test_get_pending_verdicts_empty(self):
-        """Test _get_pending_verdicts returns empty list when no verdicts."""
-        import tempfile
-        from pathlib import Path
-
-        from vds_evolution.auto_promote import AutoPromoteConfig, AutoPromoteDaemon
-
-        with tempfile.TemporaryDirectory() as tmpdir:
-            config = AutoPromoteConfig(verdict_root=Path(tmpdir))
-            daemon = AutoPromoteDaemon(config)
-
-            pending = daemon._get_pending_verdicts()
-            assert pending == []