vim(test[harness]): Add tests for multi-ref compare and delta computation

why: Validate the extracted _compute_deltas() helper and the new
compare_multi() code path with both unit and integration tests.
what:
- Add test_compute_deltas_classifies_scenarios unit test with synthetic
  BenchmarkReport objects testing noise/faster/slower classification
- Add test_compare_multi_two_refs_produces_pairwise_report smoke test
- Assert compare_multi_refs MCP tool is registered

Author: tony

tests/pytest/test_compare_smoke.py

@@ -7,7 +7,7 @@
 
 import pytest
 
-from libtestvim import CompareSpec
+from libtestvim import CompareSpec, MultiCompareReport
 from libtestvim.gitmeta import detect_origin_default_ref
 
 
@@ -73,3 +73,48 @@ def test_compare_default_ref_runs_correctness_and_cleans_up_worktrees(
     assert not report.artifact_bundle.root.is_relative_to(repo_root / "artifacts" / "vim")
     assert (report.artifact_bundle.root / "compare.json").is_file()
     assert worktrees_after == worktrees_before
+
+
+@pytest.mark.benchmark
+def test_compare_multi_two_refs_produces_pairwise_report(
+    repo_root: Path,
+    vim_harness,
+) -> None:
+    if shutil.which(vim_harness.spec.hyperfine_bin) is None:
+        pytest.skip("hyperfine is not installed")
+
+    benchmark = replace(
+        vim_harness.default_benchmark_spec(
+            label="compare-multi-smoke",
+            emit_bundle=True,
+            append_history=False,
+        ),
+        warmup_runs=0,
+        timed_runs=1,
+    )
+    worktrees_before = _worktree_roots(repo_root)
+
+    report = vim_harness.compare_multi(
+        ("HEAD", "HEAD"),
+        CompareSpec(
+            emit_bundle=True,
+            run_correctness=False,
+            benchmark=benchmark,
+        ),
+    )
+
+    worktrees_after = _worktree_roots(repo_root)
+
+    assert isinstance(report, MultiCompareReport)
+    assert report.refs == ("HEAD", "HEAD")
+    assert len(report.commits) == 2
+    assert len(report.pairwise) == 1
+    pair = report.pairwise[0]
+    assert pair.base_ref == "HEAD"
+    assert pair.target_ref == "HEAD"
+    assert len(pair.scenarios) == 5
+    for delta in pair.scenarios:
+        assert delta.classification == "noise"
+    assert report.artifact_bundle is not None
+    assert (report.artifact_bundle.root / "multi-compare.json").is_file()
+    assert worktrees_after == worktrees_before

tests/pytest/test_libtestvim_interfaces.py

@@ -55,7 +55,7 @@ def test_mcp_tool_schemas_and_resources(vim_harness) -> None:
     async def scenario() -> None:
         async with fastmcp.Client(build_mcp_server(vim_harness)) as client:
             tools = {tool.name: tool for tool in await client.list_tools()}
-            assert {"probe_vim", "run_vim", "benchmark_vim", "compare_refs"} <= tools.keys()
+            assert {"probe_vim", "run_vim", "benchmark_vim", "compare_refs", "compare_multi_refs"} <= tools.keys()
 
             probe_tool = tools["probe_vim"]
             assert probe_tool.outputSchema is not None
@@ -138,6 +138,77 @@ async def scenario() -> None:
     run_async(scenario())
 
 
+def test_compute_deltas_classifies_scenarios(vim_harness) -> None:
+    from pathlib import Path
+
+    from libtestvim.models import (
+        BenchmarkReport,
+        BenchmarkScenarioResult,
+        CapabilityReport,
+        EnvironmentReport,
+        GitRepoState,
+    )
+
+    cap = CapabilityReport(
+        vim_bin="vim",
+        version_line="VIM 9.1",
+        version_output="",
+        feature_flags=(),
+        supports_profile=False,
+        supports_channel_log=False,
+        supports_startuptime=False,
+        supports_getscriptinfo=False,
+    )
+    env = EnvironmentReport(
+        repo_root=Path("."),
+        vimrc_path=Path("vimrc"),
+        plugin_root=None,
+        fzf_root=None,
+        artifact_root=Path("."),
+        fixture_root=None,
+        tools=(),
+        git=GitRepoState(root=Path("."), branch="main", commit="abc", is_dirty=False),
+    )
+
+    def make_report(*scenarios: tuple[str, float]) -> BenchmarkReport:
+        return BenchmarkReport(
+            version=1,
+            run_id="test",
+            generated_at="2026-01-01T00:00:00+00:00",
+            label="test",
+            capability=cap,
+            environment=env,
+            plugin_manifest=(),
+            scenarios=tuple(
+                BenchmarkScenarioResult(
+                    name=name,
+                    command="vim",
+                    mean_seconds=mean,
+                    min_seconds=mean,
+                    max_seconds=mean,
+                )
+                for name, mean in scenarios
+            ),
+        )
+
+    base = make_report(("fast", 0.100), ("slow", 0.200), ("same", 0.150))
+    target = make_report(("fast", 0.080), ("slow", 0.220), ("same", 0.152))
+
+    deltas = vim_harness._compute_deltas(base, target)
+
+    assert len(deltas) == 3
+    by_name = {d.name: d for d in deltas}
+
+    assert by_name["fast"].classification == "faster"
+    assert by_name["fast"].percent_delta < -5
+
+    assert by_name["slow"].classification == "slower"
+    assert by_name["slow"].percent_delta > 5
+
+    assert by_name["same"].classification == "noise"
+    assert abs(by_name["same"].percent_delta) < 5
+
+
 def test_run_result_schema_is_object() -> None:
     schema = json_schema(RunResult)
     assert isinstance(schema, dict)