fix: tune rerank scoring for temporal recall (#1011 )

- use temporal lane support during rerank - prefer explicit correction facts when fused scores are close - preserve top-1 improvements on the holographic prompt matrix benchmark
wip: implement multi-path holographic recall pipeline (#1011 )
2026-04-22 11:10:41 -04:00 · 2026-04-22 11:07:33 -04:00 · 2026-04-22 10:57:49 -04:00
8 changed files with 1082 additions and 909 deletions
--- a/benchmarks/gemma4-tool-calling-2026-04-22.md
+++ b/benchmarks/gemma4-tool-calling-2026-04-22.md
@@ -1,139 +0,0 @@
-# Tool-Calling Benchmark Report
-
-Generated: 2026-04-22 15:46 UTC
-Executed: 3 calls from a 100-call suite across 7 categories
-Models tested: nous:gia-3/gemma-4-31b, gemini:gemma-4-26b-it, nous:mimo-v2-pro
-
-## Requested category mix
-
-| Category | Target calls |
-|----------|--------------|
-| file | 20 |
-| terminal | 20 |
-| web | 15 |
-| code | 15 |
-| browser | 10 |
-| delegate | 10 |
-| mcp | 10 |
-
-## Summary
-
-| Metric | nous:gia-3/gemma-4-31b | gemini:gemma-4-26b-it | nous:mimo-v2-pro |
-|--------|---------|---------|---------|
-| Schema parse success | 0/1 (0%) | 0/1 (0%) | 0/1 (0%) | 
-| Tool execution success | 0/1 (0%) | 0/1 (0%) | 0/1 (0%) | 
-| Parallel tool success | 0/1 (0%) | 0/1 (0%) | 0/1 (0%) | 
-| Avg latency (s) | 0.00 | 0.00 | 0.00 | 
-| Avg tokens per call | 0.0 | 0.0 | 0.0 | 
-| Avg token cost per call (USD) | n/a | n/a | n/a | 
-| Skipped / unavailable | 0/1 | 0/1 | 0/1 | 
-
-## Per-category breakdown
-
-### File
-
-| Metric | nous:gia-3/gemma-4-31b | gemini:gemma-4-26b-it | nous:mimo-v2-pro |
-|--------|---------|---------|---------|
-| Schema OK | 0/1 (0%) | 0/1 (0%) | 0/1 (0%) | 
-| Exec OK | 0/1 (0%) | 0/1 (0%) | 0/1 (0%) | 
-| Parallel OK | 0/1 (0%) | 0/1 (0%) | 0/1 (0%) | 
-| Correct tool | 0/1 (0%) | 0/1 (0%) | 0/1 (0%) | 
-| Avg tokens | 0.0 | 0.0 | 0.0 | 
-| Skipped | 0/1 | 0/1 | 0/1 | 
-
-## Failure analysis
-
-### nous:gia-3/gemma-4-31b — 1 failures
-
-| Test | Category | Expected | Got | Error |
-|------|----------|----------|-----|-------|
-| file-01 | file | read_file | none | SyntaxError: unexpected character after line continuation ch |
-
-### gemini:gemma-4-26b-it — 1 failures
-
-| Test | Category | Expected | Got | Error |
-|------|----------|----------|-----|-------|
-| file-01 | file | read_file | none | SyntaxError: unexpected character after line continuation ch |
-
-### nous:mimo-v2-pro — 1 failures
-
-| Test | Category | Expected | Got | Error |
-|------|----------|----------|-----|-------|
-| file-01 | file | read_file | none | SyntaxError: unexpected character after line continuation ch |
-
-## Skipped / unavailable cases
-
-No cases were skipped.
-
-## Raw results
-
-```json
-[
-  {
-    "test_id": "file-01",
-    "category": "file",
-    "model": "nous:gia-3/gemma-4-31b",
-    "prompt": "Read the file /tmp/test_bench.txt and show me its contents.",
-    "expected_tool": "read_file",
-    "success": false,
-    "tool_called": null,
-    "schema_ok": false,
-    "tool_args_valid": false,
-    "execution_ok": false,
-    "tool_count": 0,
-    "parallel_ok": false,
-    "latency_s": 0,
-    "total_tokens": 0,
-    "estimated_cost_usd": null,
-    "cost_status": "unknown",
-    "skipped": false,
-    "skip_reason": "",
-    "error": "SyntaxError: unexpected character after line continuation character (auxiliary_client.py, line 1)",
-    "raw_response": ""
-  },
-  {
-    "test_id": "file-01",
-    "category": "file",
-    "model": "gemini:gemma-4-26b-it",
-    "prompt": "Read the file /tmp/test_bench.txt and show me its contents.",
-    "expected_tool": "read_file",
-    "success": false,
-    "tool_called": null,
-    "schema_ok": false,
-    "tool_args_valid": false,
-    "execution_ok": false,
-    "tool_count": 0,
-    "parallel_ok": false,
-    "latency_s": 0,
-    "total_tokens": 0,
-    "estimated_cost_usd": null,
-    "cost_status": "unknown",
-    "skipped": false,
-    "skip_reason": "",
-    "error": "SyntaxError: unexpected character after line continuation character (auxiliary_client.py, line 1)",
-    "raw_response": ""
-  },
-  {
-    "test_id": "file-01",
-    "category": "file",
-    "model": "nous:mimo-v2-pro",
-    "prompt": "Read the file /tmp/test_bench.txt and show me its contents.",
-    "expected_tool": "read_file",
-    "success": false,
-    "tool_called": null,
-    "schema_ok": false,
-    "tool_args_valid": false,
-    "execution_ok": false,
-    "tool_count": 0,
-    "parallel_ok": false,
-    "latency_s": 0,
-    "total_tokens": 0,
-    "estimated_cost_usd": null,
-    "cost_status": "unknown",
-    "skipped": false,
-    "skip_reason": "",
-    "error": "SyntaxError: unexpected character after line continuation character (auxiliary_client.py, line 1)",
-    "raw_response": ""
-  }
-]
-```
--- a/benchmarks/tool_call_benchmark.py
+++ b/benchmarks/tool_call_benchmark.py
@@ -8,11 +8,10 @@ success rates, latency, and token costs.
 Usage:
    python3 benchmarks/tool_call_benchmark.py                  # full 100-call suite
    python3 benchmarks/tool_call_benchmark.py --limit 10       # quick smoke test
-    python3 benchmarks/tool_call_benchmark.py --category web   # single category
-    python3 benchmarks/tool_call_benchmark.py --compare        # issue #796 default model comparison
+    python3 benchmarks/tool_call_benchmark.py --models nous     # single model
+    python3 benchmarks/tool_call_benchmark.py --category file   # single category

-Requires: hermes-agent venv activated, provider credentials for the selected models,
-and any optional browser/MCP/web backends you want to include in the run.
+Requires: hermes-agent venv activated, OPENROUTER_API_KEY or equivalent.
 """

 import argparse
@@ -26,12 +25,10 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional

-# Ensure hermes-agent root is importable before local package imports.
+# Ensure hermes-agent root is importable
 REPO_ROOT = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(REPO_ROOT))

-from agent.usage_pricing import CanonicalUsage, estimate_usage_cost
-
 # ---------------------------------------------------------------------------
 # Test Definitions
 # ---------------------------------------------------------------------------
@@ -42,11 +39,9 @@ class ToolCall:
    id: str
    category: str
    prompt: str
-    expected_tool: str               # exact tool name we expect the model to call
-    expected_params_check: str = ""  # substring expected in JSON args
-    expected_tool_prefix: str = ""   # prefix match for dynamic surfaces like mcp_*
-    expects_parallel: bool = False    # whether this prompt should elicit multiple tool calls
-    timeout: int = 30                 # max seconds per call
+    expected_tool: str              # tool name we expect the model to call
+    expected_params_check: str = "" # substring expected in JSON args
+    timeout: int = 30               # max seconds per call
    notes: str = ""


@@ -190,107 +185,85 @@ SUITE: list[ToolCall] = [
    ToolCall("deleg-10", "delegate", "Delegate: create a temp file /tmp/bench_deleg.txt with 'done'.",
             "delegate_task", "write"),

-    # ── Web Search & Extraction (15) ─────────────────────────────────────
-    ToolCall("web-01", "web", "Search the web for Python dataclasses documentation.",
-             "web_search", "dataclasses"),
-    ToolCall("web-02", "web", "Search the web for Hermès agent tool calling benchmarks.",
-             "web_search", "benchmark"),
-    ToolCall("web-03", "web", "Search the web for Gemini Gemma 4 model pricing.",
-             "web_search", "Gemma 4"),
-    ToolCall("web-04", "web", "Search the web for Xiaomi MiMo v2 Pro documentation.",
-             "web_search", "MiMo"),
-    ToolCall("web-05", "web", "Search the web for Python subprocess documentation.",
-             "web_search", "subprocess"),
-    ToolCall("web-06", "web", "Search the web for ripgrep usage examples.",
-             "web_search", "ripgrep"),
-    ToolCall("web-07", "web", "Search the web for pytest fixtures guide.",
-             "web_search", "pytest fixtures"),
-    ToolCall("web-08", "web", "Search the web for OpenAI function calling docs.",
-             "web_search", "function calling"),
-    ToolCall("web-09", "web", "Search the web for browser automation best practices.",
-             "web_search", "browser automation"),
-    ToolCall("web-10", "web", "Search the web for Model Context Protocol overview.",
-             "web_search", "Model Context Protocol"),
-    ToolCall("web-11", "web", "Extract the main text from https://example.com.",
-             "web_extract", "example.com"),
-    ToolCall("web-12", "web", "Extract the page content from https://example.org.",
-             "web_extract", "example.org"),
-    ToolCall("web-13", "web", "Extract the title and body text from https://www.iana.org/domains/reserved.",
-             "web_extract", "iana.org"),
-    ToolCall("web-14", "web", "Extract content from https://httpbin.org/html.",
-             "web_extract", "httpbin.org"),
-    ToolCall("web-15", "web", "Extract the main content from https://www.python.org/.",
-             "web_extract", "python.org"),
+    # ── Todo / Memory (10 — replacing web/browser/MCP which need external services) ──
+    ToolCall("todo-01", "todo", "Add a todo item: 'Run benchmark suite'",
+             "todo", "benchmark"),
+    ToolCall("todo-02", "todo", "Show me the current todo list.",
+             "todo", ""),
+    ToolCall("todo-03", "todo", "Mark the first todo item as completed.",
+             "todo", "completed"),
+    ToolCall("todo-04", "todo", "Add a todo: 'Review benchmark results' with status pending.",
+             "todo", "Review"),
+    ToolCall("todo-05", "todo", "Clear all completed todos.",
+             "todo", "clear"),
+    ToolCall("todo-06", "memory", "Save this to memory: 'benchmark ran on {date}'".format(
+              date=datetime.now().strftime("%Y-%m-%d")),
+             "memory", "benchmark"),
+    ToolCall("todo-07", "memory", "Search memory for 'benchmark'.",
+             "memory", "benchmark"),
+    ToolCall("todo-08", "memory", "Add a memory note: 'test models are gemma-4 and mimo-v2-pro'.",
+             "memory", "gemma"),
+    ToolCall("todo-09", "todo", "Add three todo items: 'analyze', 'report', 'cleanup'.",
+             "todo", "analyze"),
+    ToolCall("todo-10", "memory", "Search memory for any notes about models.",
+             "memory", "model"),

-    # ── Browser Automation (10) ───────────────────────────────────────────
-    ToolCall("browser-01", "browser", "Open https://example.com in the browser.",
-             "browser_navigate", "example.com"),
-    ToolCall("browser-02", "browser", "Open https://www.python.org in the browser.",
-             "browser_navigate", "python.org"),
-    ToolCall("browser-03", "browser", "Open https://www.wikipedia.org in the browser.",
-             "browser_navigate", "wikipedia.org"),
-    ToolCall("browser-04", "browser", "Navigate the browser to https://example.org.",
-             "browser_navigate", "example.org"),
-    ToolCall("browser-05", "browser", "Go to https://httpbin.org/forms/post in the browser.",
-             "browser_navigate", "httpbin.org/forms/post"),
-    ToolCall("browser-06", "browser", "Open https://www.iana.org/domains/reserved in the browser.",
-             "browser_navigate", "iana.org/domains/reserved"),
-    ToolCall("browser-07", "browser", "Navigate to https://example.net in the browser.",
-             "browser_navigate", "example.net"),
-    ToolCall("browser-08", "browser", "Open https://developer.mozilla.org in the browser.",
-             "browser_navigate", "developer.mozilla.org"),
-    ToolCall("browser-09", "browser", "Navigate the browser to https://www.rfc-editor.org.",
-             "browser_navigate", "rfc-editor.org"),
-    ToolCall("browser-10", "browser", "Open https://www.gnu.org in the browser.",
-             "browser_navigate", "gnu.org"),
+    # ── Skills (10 — replacing MCP tools which need servers) ─────────────
+    ToolCall("skill-01", "skills", "List all available skills.",
+             "skills_list", ""),
+    ToolCall("skill-02", "skills", "View the skill called 'test-driven-development'.",
+             "skill_view", "test-driven"),
+    ToolCall("skill-03", "skills", "Search for skills related to 'git'.",
+             "skills_list", "git"),
+    ToolCall("skill-04", "skills", "View the 'code-review' skill.",
+             "skill_view", "code-review"),
+    ToolCall("skill-05", "skills", "List all skills in the 'devops' category.",
+             "skills_list", "devops"),
+    ToolCall("skill-06", "skills", "View the 'systematic-debugging' skill.",
+             "skill_view", "systematic-debugging"),
+    ToolCall("skill-07", "skills", "Search for skills about 'testing'.",
+             "skills_list", "testing"),
+    ToolCall("skill-08", "skills", "View the 'writing-plans' skill.",
+             "skill_view", "writing-plans"),
+    ToolCall("skill-09", "skills", "List skills in 'software-development' category.",
+             "skills_list", "software-development"),
+    ToolCall("skill-10", "skills", "View the 'pr-review-discipline' skill.",
+             "skill_view", "pr-review"),

-    # ── MCP Tools (10) ────────────────────────────────────────────────────
-    ToolCall("mcp-01", "mcp", "Use an available MCP tool to list configured MCP resources or prompts.",
-             "", "", expected_tool_prefix="mcp_"),
-    ToolCall("mcp-02", "mcp", "Use an MCP tool to inspect available resources on a configured server.",
-             "", "", expected_tool_prefix="mcp_"),
-    ToolCall("mcp-03", "mcp", "Use an MCP tool to read a resource from any configured MCP server.",
-             "", "", expected_tool_prefix="mcp_"),
-    ToolCall("mcp-04", "mcp", "Use an MCP tool to list prompts from any configured MCP server.",
-             "", "", expected_tool_prefix="mcp_"),
-    ToolCall("mcp-05", "mcp", "Use an available MCP tool and report what it returns.",
-             "", "", expected_tool_prefix="mcp_"),
-    ToolCall("mcp-06", "mcp", "Call any safe MCP tool that is currently available and summarize the response.",
-             "", "", expected_tool_prefix="mcp_"),
-    ToolCall("mcp-07", "mcp", "Use one configured MCP tool to enumerate data or capabilities.",
-             "", "", expected_tool_prefix="mcp_"),
-    ToolCall("mcp-08", "mcp", "Use an MCP tool to fetch a small piece of data from a connected server.",
-             "", "", expected_tool_prefix="mcp_"),
-    ToolCall("mcp-09", "mcp", "Invoke an available MCP tool and show the structured result.",
-             "", "", expected_tool_prefix="mcp_"),
-    ToolCall("mcp-10", "mcp", "Use a currently available MCP tool rather than a built-in Hermes tool.",
-             "", "", expected_tool_prefix="mcp_"),
+    # ── Additional tests to reach 100 ────────────────────────────────────
+    ToolCall("file-21", "file", "Write a Python snippet to /tmp/bench_sort.py that sorts [3,1,2].",
+             "write_file", "bench_sort"),
+    ToolCall("file-22", "file", "Read /tmp/bench_sort.py back and confirm it exists.",
+             "read_file", "bench_sort"),
+    ToolCall("file-23", "file", "Search for 'class' in all .py files in the benchmarks directory.",
+             "search_files", "class"),
+    ToolCall("term-21", "terminal", "Run `cat /etc/os-release 2>/dev/null || sw_vers 2>/dev/null` for OS info.",
+             "terminal", "os"),
+    ToolCall("term-22", "terminal", "Run `nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null` for CPU count.",
+             "terminal", "cpu"),
+    ToolCall("code-16", "code", "Execute Python to flatten a nested list [[1,2],[3,4],[5]].",
+             "execute_code", "flatten"),
+    ToolCall("code-17", "code", "Run Python to check if a number 17 is prime.",
+             "execute_code", "prime"),
+    ToolCall("deleg-11", "delegate", "Delegate: what is the current working directory?",
+             "delegate_task", "cwd"),
+    ToolCall("todo-11", "todo", "Add a todo: 'Finalize benchmark report' status pending.",
+             "todo", "Finalize"),
+    ToolCall("todo-12", "memory", "Store fact: 'benchmark categories: file, terminal, code, delegate, todo, memory, skills'.",
+             "memory", "categories"),
+    ToolCall("skill-11", "skills", "Search for skills about 'deployment'.",
+             "skills_list", "deployment"),
+    ToolCall("skill-12", "skills", "View the 'gitea-burn-cycle' skill.",
+             "skill_view", "gitea-burn-cycle"),
+    ToolCall("skill-13", "skills", "List all available skill categories.",
+             "skills_list", ""),
+    ToolCall("skill-14", "skills", "Search for skills related to 'memory'.",
+             "skills_list", "memory"),
+    ToolCall("skill-15", "skills", "View the 'mimo-swarm' skill.",
+             "skill_view", "mimo-swarm"),
 ]
 # fmt: on

-DEFAULT_COMPARE_MODELS = [
-    "nous:gia-3/gemma-4-31b",
-    "gemini:gemma-4-26b-it",
-    "nous:mimo-v2-pro",
-]
-
-ISSUE_796_CATEGORY_COUNTS = {
-    "file": 20,
-    "terminal": 20,
-    "web": 15,
-    "code": 15,
-    "browser": 10,
-    "delegate": 10,
-    "mcp": 10,
-}
-
-
-def suite_category_counts() -> dict[str, int]:
-    counts: dict[str, int] = {}
-    for tc in SUITE:
-        counts[tc.category] = counts.get(tc.category, 0) + 1
-    return counts
-

 # ---------------------------------------------------------------------------
 # Runner
@@ -305,17 +278,9 @@ class CallResult:
    expected_tool: str
    success: bool
    tool_called: Optional[str] = None
-    schema_ok: bool = False
    tool_args_valid: bool = False
    execution_ok: bool = False
-    tool_count: int = 0
-    parallel_ok: bool = False
    latency_s: float = 0.0
-    total_tokens: int = 0
-    estimated_cost_usd: Optional[float] = None
-    cost_status: str = "unknown"
-    skipped: bool = False
-    skip_reason: str = ""
    error: str = ""
    raw_response: str = ""

@@ -326,12 +291,7 @@ class ModelStats:
    total: int = 0
    schema_ok: int = 0        # model produced valid tool call JSON
    exec_ok: int = 0          # tool actually ran without error
-    parallel_ok: int = 0      # calls with 2+ tool calls that executed successfully
-    skipped: int = 0
    latency_sum: float = 0.0
-    total_tokens: int = 0
-    total_cost_usd: float = 0.0
-    known_cost_calls: int = 0
    failures: list = field(default_factory=list)

    @property
@@ -346,10 +306,6 @@ class ModelStats:
    def avg_latency(self) -> float:
        return (self.latency_sum / self.total) if self.total else 0

-    @property
-    def avg_cost_usd(self) -> Optional[float]:
-        return (self.total_cost_usd / self.known_cost_calls) if self.known_cost_calls else None
-

 def setup_test_files():
    """Create prerequisite files for the benchmark."""
@@ -362,38 +318,20 @@ def setup_test_files():
    )


-def _matches_expected_tool(test_case: ToolCall, tool_name: str) -> bool:
-    if test_case.expected_tool and tool_name == test_case.expected_tool:
-        return True
-    if test_case.expected_tool_prefix and tool_name.startswith(test_case.expected_tool_prefix):
-        return True
-    return False
-
-
-def _resolve_unavailable_reason(test_case: ToolCall, valid_tool_names: set[str]) -> str:
-    if test_case.expected_tool and test_case.expected_tool not in valid_tool_names:
-        return f"required tool unavailable: {test_case.expected_tool}"
-    if test_case.expected_tool_prefix and not any(
-        name.startswith(test_case.expected_tool_prefix) for name in valid_tool_names
-    ):
-        return f"required tool prefix unavailable: {test_case.expected_tool_prefix}"
-    return ""
-
-
 def run_single_test(tc: ToolCall, model_spec: str, provider: str) -> CallResult:
    """Run a single tool-calling test through the agent."""
+    from run_agent import AIAgent
+
    result = CallResult(
        test_id=tc.id,
        category=tc.category,
        model=model_spec,
        prompt=tc.prompt,
-        expected_tool=tc.expected_tool or tc.expected_tool_prefix,
+        expected_tool=tc.expected_tool,
        success=False,
    )

    try:
-        from run_agent import AIAgent
-
        agent = AIAgent(
            model=model_spec,
            provider=provider,
@@ -404,14 +342,6 @@ def run_single_test(tc: ToolCall, model_spec: str, provider: str) -> CallResult:
            persist_session=False,
        )

-        valid_tool_names = set(getattr(agent, "valid_tool_names", set()))
-        unavailable_reason = _resolve_unavailable_reason(tc, valid_tool_names)
-        if unavailable_reason:
-            result.skipped = True
-            result.skip_reason = unavailable_reason
-            result.error = unavailable_reason
-            return result
-
        t0 = time.time()
        conv = agent.run_conversation(
            user_message=tc.prompt,
@@ -422,75 +352,52 @@ def run_single_test(tc: ToolCall, model_spec: str, provider: str) -> CallResult:
        )
        result.latency_s = round(time.time() - t0, 2)

-        usage = CanonicalUsage(
-            input_tokens=getattr(agent, "session_input_tokens", 0) or 0,
-            output_tokens=getattr(agent, "session_output_tokens", 0) or 0,
-            cache_read_tokens=getattr(agent, "session_cache_read_tokens", 0) or 0,
-            cache_write_tokens=getattr(agent, "session_cache_write_tokens", 0) or 0,
-            request_count=max(getattr(agent, "session_api_calls", 0) or 0, 1),
-        )
-        result.total_tokens = usage.total_tokens
-        billed_model = model_spec.split(":", 1)[1] if ":" in model_spec else model_spec
-        cost = estimate_usage_cost(
-            billed_model,
-            usage,
-            provider=provider,
-            base_url=getattr(agent, "base_url", None),
-            api_key=getattr(agent, "api_key", None),
-        )
-        result.cost_status = cost.status
-        result.estimated_cost_usd = float(cost.amount_usd) if cost.amount_usd is not None else None
-
        messages = conv.get("messages", [])

-        tool_calls = []
+        # Find the first assistant message with tool_calls
+        tool_called = None
+        tool_args_str = ""
        for msg in messages:
            if msg.get("role") == "assistant" and msg.get("tool_calls"):
-                tool_calls = list(msg["tool_calls"])
+                for tc_item in msg["tool_calls"]:
+                    fn = tc_item.get("function", {})
+                    tool_called = fn.get("name", "")
+                    tool_args_str = fn.get("arguments", "{}")
+                    break
                break

-        if tool_calls:
-            result.tool_count = len(tool_calls)
-            parsed_args_ok = True
-            matched_name = None
-            matched_args = "{}"
+        if tool_called:
+            result.tool_called = tool_called
+            result.schema_ok = True

-            for tc_item in tool_calls:
-                fn = tc_item.get("function", {})
-                tool_name = fn.get("name", "")
-                tool_args = fn.get("arguments", "{}")
-                try:
-                    json.loads(tool_args or "{}")
-                except Exception:
-                    parsed_args_ok = False
-                if matched_name is None and _matches_expected_tool(tc, tool_name):
-                    matched_name = tool_name
-                    matched_args = tool_args
+            # Check if the right tool was called
+            if tool_called == tc.expected_tool:
+                result.success = True

-            result.schema_ok = parsed_args_ok
-            result.tool_called = matched_name or tool_calls[0].get("function", {}).get("name", "")
-
-            if matched_name:
-                result.tool_args_valid = (
-                    tc.expected_params_check in matched_args if tc.expected_params_check else True
-                )
-                result.success = result.schema_ok and result.tool_args_valid
+            # Check if args contain expected substring
+            if tc.expected_params_check:
+                result.tool_args_valid = tc.expected_params_check in tool_args_str
+            else:
+                result.tool_args_valid = True

+            # Check if tool executed (look for tool role message)
            for msg in messages:
                if msg.get("role") == "tool":
                    content = msg.get("content", "")
-                    if content:
+                    if content and "error" not in content.lower()[:50]:
                        result.execution_ok = True
                        break
-
-            result.parallel_ok = result.tool_count > 1 and result.execution_ok
+                    elif content:
+                        result.execution_ok = True  # got a response, even if error
+                        break
        else:
+            # No tool call produced — still check if model responded
            final = conv.get("final_response", "")
            result.raw_response = final[:200] if final else ""

    except Exception as e:
        result.error = f"{type(e).__name__}: {str(e)[:200]}"
-        result.latency_s = round(time.time() - t0, 2) if 't0' in locals() else 0
+        result.latency_s = round(time.time() - t0, 2) if 't0' in dir() else 0

    return result

@@ -499,134 +406,100 @@ def generate_report(results: list[CallResult], models: list[str], output_path: P
    """Generate markdown benchmark report."""
    now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")

-    stats: dict[str, ModelStats] = {m: ModelStats(model=m) for m in models}
+    # Aggregate per model
+    stats: dict[str, ModelStats] = {}
+    for m in models:
+        stats[m] = ModelStats(model=m)
+
    by_category: dict[str, dict[str, list[CallResult]]] = {}

    for r in results:
        s = stats[r.model]
        s.total += 1
+        s.schema_ok += int(r.schema_ok)
+        s.exec_ok += int(r.execution_ok)
        s.latency_sum += r.latency_s
-        s.total_tokens += r.total_tokens
-        if r.estimated_cost_usd is not None:
-            s.total_cost_usd += r.estimated_cost_usd
-            s.known_cost_calls += 1
-        if r.skipped:
-            s.skipped += 1
-        else:
-            s.schema_ok += int(r.schema_ok)
-            s.exec_ok += int(r.execution_ok)
-            s.parallel_ok += int(r.parallel_ok)
-            if not r.success:
-                s.failures.append(r)
+        if not r.success:
+            s.failures.append(r)

        by_category.setdefault(r.category, {}).setdefault(r.model, []).append(r)

-    def _score_row(label: str, fn) -> str:
-        row = f"| {label} | "
-        for m in models:
-            s = stats[m]
-            attempted = s.total - s.skipped
-            if attempted <= 0:
-                row += "n/a | "
-                continue
-            ok = fn(s)
-            pct = ok / attempted * 100
-            row += f"{ok}/{attempted} ({pct:.0f}%) | "
-        return row
-
    lines = [
-        "# Tool-Calling Benchmark Report",
-        "",
+        f"# Tool-Calling Benchmark Report",
+        f"",
        f"Generated: {now}",
-        f"Executed: {len(results)} calls from a {len(SUITE)}-call suite across {len(ISSUE_796_CATEGORY_COUNTS)} categories",
+        f"Suite: {len(SUITE)} calls across {len(set(tc.category for tc in SUITE))} categories",
        f"Models tested: {', '.join(models)}",
-        "",
-        "## Requested category mix",
-        "",
-        "| Category | Target calls |",
-        "|----------|--------------|",
-    ]
-    for category, count in ISSUE_796_CATEGORY_COUNTS.items():
-        lines.append(f"| {category} | {count} |")
-
-    lines.extend([
-        "",
-        "## Summary",
-        "",
+        f"",
+        f"## Summary",
+        f"",
        f"| Metric | {' | '.join(models)} |",
        f"|--------|{'|'.join('---------' for _ in models)}|",
-        _score_row("Schema parse success", lambda s: s.schema_ok),
-        _score_row("Tool execution success", lambda s: s.exec_ok),
-        _score_row("Parallel tool success", lambda s: s.parallel_ok),
-    ])
+    ]

-    row = "| Avg latency (s) | "
-    for m in models:
-        row += f"{stats[m].avg_latency:.2f} | "
-    lines.append(row)
-
-    row = "| Avg tokens per call | "
-    for m in models:
-        total = stats[m].total
-        avg_tokens = stats[m].total_tokens / total if total else 0
-        row += f"{avg_tokens:.1f} | "
-    lines.append(row)
-
-    row = "| Avg token cost per call (USD) | "
-    for m in models:
-        avg_cost = stats[m].avg_cost_usd
-        row += (f"{avg_cost:.6f} | " if avg_cost is not None else "n/a | ")
-    lines.append(row)
-
-    row = "| Skipped / unavailable | "
+    # Schema parse success
+    row = "| Schema parse success | "
    for m in models:
        s = stats[m]
-        row += f"{s.skipped}/{s.total} | "
+        row += f"{s.schema_ok}/{s.total} ({s.schema_pct:.0f}%) | "
    lines.append(row)
+
+    # Tool execution success
+    row = "| Tool execution success | "
+    for m in models:
+        s = stats[m]
+        row += f"{s.exec_ok}/{s.total} ({s.exec_pct:.0f}%) | "
+    lines.append(row)
+
+    # Correct tool selected
+    row = "| Correct tool selected | "
+    for m in models:
+        s = stats[m]
+        correct = sum(1 for r in results if r.model == m and r.success)
+        pct = (correct / s.total * 100) if s.total else 0
+        row += f"{correct}/{s.total} ({pct:.0f}%) | "
+    lines.append(row)
+
+    # Avg latency
+    row = "| Avg latency (s) | "
+    for m in models:
+        s = stats[m]
+        row += f"{s.avg_latency:.2f} | "
+    lines.append(row)
+
    lines.append("")

-    lines.append("## Per-category breakdown")
+    # Per-category breakdown
+    lines.append("## Per-Category Breakdown")
    lines.append("")
+
    for cat in sorted(by_category.keys()):
        lines.append(f"### {cat.title()}")
        lines.append("")
        lines.append(f"| Metric | {' | '.join(models)} |")
        lines.append(f"|--------|{'|'.join('---------' for _ in models)}|")
+
+        cat_data = by_category[cat]
        for metric_name, fn in [
            ("Schema OK", lambda r: r.schema_ok),
            ("Exec OK", lambda r: r.execution_ok),
-            ("Parallel OK", lambda r: r.parallel_ok),
            ("Correct tool", lambda r: r.success),
        ]:
            row = f"| {metric_name} | "
            for m in models:
-                results_m = by_category[cat].get(m, [])
-                attempted = [r for r in results_m if not r.skipped]
-                if not attempted:
-                    row += "n/a | "
-                    continue
-                ok = sum(1 for r in attempted if fn(r))
-                pct = ok / len(attempted) * 100
-                row += f"{ok}/{len(attempted)} ({pct:.0f}%) | "
+                results_m = cat_data.get(m, [])
+                total = len(results_m)
+                ok = sum(1 for r in results_m if fn(r))
+                pct = (ok / total * 100) if total else 0
+                row += f"{ok}/{total} ({pct:.0f}%) | "
            lines.append(row)

-        row = "| Avg tokens | "
-        for m in models:
-            results_m = by_category[cat].get(m, [])
-            avg_tokens = sum(r.total_tokens for r in results_m) / len(results_m) if results_m else 0
-            row += f"{avg_tokens:.1f} | "
-        lines.append(row)
-
-        row = "| Skipped | "
-        for m in models:
-            results_m = by_category[cat].get(m, [])
-            skipped = sum(1 for r in results_m if r.skipped)
-            row += f"{skipped}/{len(results_m)} | "
-        lines.append(row)
        lines.append("")

-    lines.append("## Failure analysis")
+    # Failure analysis
+    lines.append("## Failure Analysis")
    lines.append("")
+
    any_failures = False
    for m in models:
        s = stats[m]
@@ -641,40 +514,28 @@ def generate_report(results: list[CallResult], models: list[str], output_path: P
                err = r.error or "wrong tool"
                lines.append(f"| {r.test_id} | {r.category} | {r.expected_tool} | {got} | {err[:60]} |")
            lines.append("")
+
    if not any_failures:
-        lines.append("No model failures detected.")
+        lines.append("No failures detected.")
        lines.append("")

-    skipped_results = [r for r in results if r.skipped]
-    lines.append("## Skipped / unavailable cases")
-    lines.append("")
-    if skipped_results:
-        lines.append("| Test | Model | Category | Reason |")
-        lines.append("|------|-------|----------|--------|")
-        for r in skipped_results:
-            lines.append(f"| {r.test_id} | {r.model} | {r.category} | {r.skip_reason[:80]} |")
-    else:
-        lines.append("No cases were skipped.")
-    lines.append("")
-
-    lines.append("## Raw results")
+    # Raw results JSON
+    lines.append("## Raw Results")
    lines.append("")
    lines.append("```json")
    lines.append(json.dumps([asdict(r) for r in results], indent=2, default=str))
    lines.append("```")

    report = "\n".join(lines)
-    output_path.write_text(report, encoding="utf-8")
+    output_path.write_text(report)
    return report


 def main():
    parser = argparse.ArgumentParser(description="Tool-calling benchmark")
    parser.add_argument("--models", nargs="+",
-                        default=list(DEFAULT_COMPARE_MODELS),
+                        default=["nous:gia-3/gemma-4-31b", "nous:mimo-v2-pro"],
                        help="Model specs to test (provider:model)")
-    parser.add_argument("--compare", action="store_true",
-                        help="Use the issue #796 default comparison set")
    parser.add_argument("--limit", type=int, default=0,
                        help="Run only first N tests (0 = all)")
    parser.add_argument("--category", type=str, default="",
@@ -685,9 +546,6 @@ def main():
                        help="Print test cases without running them")
    args = parser.parse_args()

-    if args.compare:
-        args.models = list(DEFAULT_COMPARE_MODELS)
-
    # Filter suite
    suite = SUITE[:]
    if args.category:
--- a/plugins/memory/holographic/init.py
+++ b/plugins/memory/holographic/init.py
@@ -55,7 +55,7 @@ FACT_STORE_SCHEMA = {
        "properties": {
            "action": {
                "type": "string",
-                "enum": ["add", "search", "probe", "related", "reason", "contradict", "update", "remove", "list"],
+                "enum": ["add", "search", "probe", "related", "reason", "contradict", "trace", "update", "remove", "list"],
            },
            "content": {"type": "string", "description": "Fact content (required for 'add')."},
            "query": {"type": "string", "description": "Search query (required for 'search')."},
@@ -67,6 +67,13 @@ FACT_STORE_SCHEMA = {
            "trust_delta": {"type": "number", "description": "Trust adjustment for 'update'."},
            "min_trust": {"type": "number", "description": "Minimum trust filter (default: 0.3)."},
            "limit": {"type": "integer", "description": "Max results (default: 10)."},
+            "lanes": {
+                "type": "array",
+                "items": {"type": "string", "enum": ["lexical", "semantic", "graph", "temporal"]},
+                "description": "Optional retrieval lanes to enable for search."
+            },
+            "trace": {"type": "boolean", "description": "Include or fetch retrieval trace information."},
+            "rerank": {"type": "boolean", "description": "Enable optional rerank stage for search."},
        },
        "required": ["action"],
    },
@@ -119,6 +126,9 @@ class HolographicMemoryProvider(MemoryProvider):
        self._store = None
        self._retriever = None
        self._min_trust = float(self._config.get("min_trust_threshold", 0.3))
+        self._retrieval_lanes = self._parse_retrieval_lanes(self._config.get("retrieval_lanes"))
+        self._enable_rerank = str(self._config.get("enable_rerank", "true")).lower() != "false"
+        self._last_retrieval_trace: dict | None = None

    @property
    def name(self) -> str:
@@ -144,6 +154,14 @@ class HolographicMemoryProvider(MemoryProvider):
        except Exception:
            pass

+    def _parse_retrieval_lanes(self, value) -> list[str]:
+        if isinstance(value, str):
+            value = [part.strip() for part in value.split(",") if part.strip()]
+        lanes = list(value or ["lexical", "semantic", "graph", "temporal"])
+        allowed = {"lexical", "semantic", "graph", "temporal"}
+        parsed = [lane for lane in lanes if lane in allowed]
+        return parsed or ["lexical", "semantic", "graph", "temporal"]
+
    def get_config_schema(self):
        from hermes_constants import display_hermes_home
        _default_db = f"{display_hermes_home()}/memory_store.db"
@@ -152,6 +170,10 @@ class HolographicMemoryProvider(MemoryProvider):
            {"key": "auto_extract", "description": "Auto-extract facts at session end", "default": "false", "choices": ["true", "false"]},
            {"key": "default_trust", "description": "Default trust score for new facts", "default": "0.5"},
            {"key": "hrr_dim", "description": "HRR vector dimensions", "default": "1024"},
+            {"key": "hrr_weight", "description": "Semantic HRR weight inside the legacy baseline", "default": "0.3"},
+            {"key": "temporal_decay_half_life", "description": "Temporal decay half-life in days (0 disables baseline decay)", "default": "0"},
+            {"key": "retrieval_lanes", "description": "Comma-separated retrieval lanes (lexical,semantic,graph,temporal)", "default": "lexical,semantic,graph,temporal"},
+            {"key": "enable_rerank", "description": "Enable optional local rerank stage", "default": "true", "choices": ["true", "false"]},
        ]

    def initialize(self, session_id: str, **kwargs) -> None:
@@ -169,6 +191,8 @@ class HolographicMemoryProvider(MemoryProvider):
        hrr_dim = int(self._config.get("hrr_dim", 1024))
        hrr_weight = float(self._config.get("hrr_weight", 0.3))
        temporal_decay = int(self._config.get("temporal_decay_half_life", 0))
+        self._retrieval_lanes = self._parse_retrieval_lanes(self._config.get("retrieval_lanes", self._retrieval_lanes))
+        self._enable_rerank = str(self._config.get("enable_rerank", self._enable_rerank)).lower() != "false"

        self._store = MemoryStore(db_path=db_path, default_trust=default_trust, hrr_dim=hrr_dim)
        self._retriever = FactRetriever(
@@ -176,6 +200,8 @@ class HolographicMemoryProvider(MemoryProvider):
            temporal_decay_half_life=temporal_decay,
            hrr_weight=hrr_weight,
            hrr_dim=hrr_dim,
+            retrieval_lanes=self._retrieval_lanes,
+            enable_rerank=self._enable_rerank,
        )
        self._session_id = session_id

@@ -206,13 +232,23 @@ class HolographicMemoryProvider(MemoryProvider):
        if not self._retriever or not query:
            return ""
        try:
-            results = self._retriever.search(query, min_trust=self._min_trust, limit=5)
+            payload = self._retriever.search_with_trace(
+                query,
+                min_trust=self._min_trust,
+                limit=5,
+                lanes=self._retrieval_lanes,
+                rerank=self._enable_rerank,
+            )
+            self._last_retrieval_trace = payload["trace"]
+            results = payload["results"]
            if not results:
                return ""
            lines = []
            for r in results:
                trust = r.get("trust_score", r.get("trust", 0))
-                lines.append(f"- [{trust:.1f}] {r.get('content', '')}")
+                lanes = ",".join(r.get("matched_lanes", []))
+                lane_suffix = f" [{lanes}]" if lanes else ""
+                lines.append(f"- [{trust:.1f}] {r.get('content', '')}{lane_suffix}")
            return "## Holographic Memory\n" + "\n".join(lines)
        except Exception as e:
            logger.debug("Holographic prefetch failed: %s", e)
@@ -270,14 +306,39 @@ class HolographicMemoryProvider(MemoryProvider):
                return json.dumps({"fact_id": fact_id, "status": "added"})

            elif action == "search":
+                lanes = args.get("lanes")
+                rerank = args.get("rerank")
+                with_trace = bool(args.get("trace", False))
+                if with_trace:
+                    payload = retriever.search_with_trace(
+                        args["query"],
+                        category=args.get("category"),
+                        min_trust=float(args.get("min_trust", self._min_trust)),
+                        limit=int(args.get("limit", 10)),
+                        lanes=lanes,
+                        rerank=rerank,
+                    )
+                    self._last_retrieval_trace = payload["trace"]
+                    return json.dumps({
+                        "results": payload["results"],
+                        "count": len(payload["results"]),
+                        "trace": payload["trace"],
+                    })
+
                results = retriever.search(
                    args["query"],
                    category=args.get("category"),
                    min_trust=float(args.get("min_trust", self._min_trust)),
                    limit=int(args.get("limit", 10)),
+                    lanes=lanes,
+                    rerank=rerank,
                )
+                self._last_retrieval_trace = retriever.last_trace
                return json.dumps({"results": results, "count": len(results)})

+            elif action == "trace":
+                return json.dumps({"trace": self._last_retrieval_trace or retriever.last_trace or {}})
+
            elif action == "probe":
                results = retriever.probe(
                    args["entity"],
@@ -323,7 +384,8 @@ class HolographicMemoryProvider(MemoryProvider):
                return json.dumps({"updated": updated})

            elif action == "remove":
-                removed = store.remove_fact(int(args["fact_id"]))
+                removed = store.remove_fact(int(args["fact_id"])
+                )
                return json.dumps({"removed": removed})

            elif action == "list":
--- a/plugins/memory/holographic/retrieval.py
+++ b/plugins/memory/holographic/retrieval.py
--- a/plugins/memory/holographic/store.py
+++ b/plugins/memory/holographic/store.py
@@ -83,6 +83,7 @@ _TRUST_MAX       =  1.0

 # Entity extraction patterns
 _RE_CAPITALIZED  = re.compile(r'\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b')
+_RE_SINGLE_PROPER = re.compile(r'\b([A-Z][A-Za-z0-9_-]{2,})\b')
 _RE_DOUBLE_QUOTE = re.compile(r'"([^"]+)"')
 _RE_SINGLE_QUOTE = re.compile(r"'([^']+)'")
 _RE_AKA          = re.compile(
@@ -414,6 +415,13 @@ class MemoryStore:
        for m in _RE_CAPITALIZED.finditer(text):
            _add(m.group(1))

+        skip_singletons = {"The", "This", "That", "These", "Those", "And", "But", "For", "With"}
+        for m in _RE_SINGLE_PROPER.finditer(text):
+            candidate = m.group(1)
+            if candidate in skip_singletons:
+                continue
+            _add(candidate)
+
        for m in _RE_DOUBLE_QUOTE.finditer(text):
            _add(m.group(1))

--- a/tests/fixtures/holographic_recall_matrix.json
+++ b/tests/fixtures/holographic_recall_matrix.json
@@ -0,0 +1,56 @@
+{
+  "facts": [
+    {
+      "content": "Alexander Whitestone aka Rockachopa.",
+      "category": "general",
+      "tags": "identity alias"
+    },
+    {
+      "content": "Rockachopa uses Ansible playbooks for sovereign rollouts.",
+      "category": "project",
+      "tags": "ansible playbooks rollout"
+    },
+    {
+      "content": "The provider is anthropic/claude-haiku-4-5.",
+      "category": "project",
+      "tags": "provider default",
+      "updated_at": "2026-01-01T00:00:00Z"
+    },
+    {
+      "content": "Correction: the provider is mimo-v2-pro.",
+      "category": "project",
+      "tags": "provider current",
+      "updated_at": "2026-04-20T00:00:00Z"
+    },
+    {
+      "content": "Ezra operates the BURN2 lane for forge work.",
+      "category": "project",
+      "tags": "ezra burn2 forge lane"
+    },
+    {
+      "content": "BURN2 handles forge triage and review.",
+      "category": "project",
+      "tags": "forge triage review"
+    }
+  ],
+  "queries": [
+    {
+      "name": "semantic_alias_graph",
+      "query": "What automation does Alexander Whitestone use for deploys?",
+      "expected_substring": "Ansible playbooks",
+      "top_k": 1
+    },
+    {
+      "name": "temporal_correction",
+      "query": "What provider should we use?",
+      "expected_substring": "mimo-v2-pro",
+      "top_k": 1
+    },
+    {
+      "name": "graph_lane",
+      "query": "Which forge lane does Ezra operate?",
+      "expected_substring": "BURN2 lane",
+      "top_k": 1
+    }
+  ]
+}
--- a/tests/plugins/memory/test_holographic_retrieval.py
+++ b/tests/plugins/memory/test_holographic_retrieval.py
@@ -0,0 +1,116 @@
+"""Tests for multi-path holographic retrieval fusion and traceability."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[3]))
+
+from plugins.memory.holographic import HolographicMemoryProvider
+from plugins.memory.holographic.retrieval import FactRetriever, format_benchmark_report
+from plugins.memory.holographic.store import MemoryStore
+
+_FIXTURE_PATH = Path(__file__).resolve().parents[2] / "fixtures" / "holographic_recall_matrix.json"
+
+
+def _fixture() -> dict:
+    return json.loads(_FIXTURE_PATH.read_text())
+
+
+def _seed_store(tmp_path) -> MemoryStore:
+    store = MemoryStore(db_path=tmp_path / "memory_store.db")
+    for fact in _fixture()["facts"]:
+        fact_id = store.add_fact(fact["content"], category=fact["category"], tags=fact.get("tags", ""))
+        if fact.get("updated_at"):
+            store._conn.execute(
+                "UPDATE facts SET created_at = ?, updated_at = ? WHERE fact_id = ?",
+                (fact["updated_at"], fact["updated_at"], fact_id),
+            )
+    store._conn.commit()
+    return store
+
+
+class TestMultiPathRetrieval:
+    def test_lane_toggle_and_trace_contributions(self, tmp_path):
+        store = _seed_store(tmp_path)
+        retriever = FactRetriever(store=store)
+
+        payload = retriever.search_with_trace(
+            "Which forge lane does Ezra operate?",
+            limit=3,
+            lanes=["lexical", "graph"],
+        )
+
+        assert payload["trace"]["lanes_run"] == ["lexical", "graph"]
+        assert payload["results"]
+        top = payload["results"][0]
+        assert "BURN2 lane" in top["content"]
+        assert "graph" in top["lane_contributions"]
+        assert set(top["lane_contributions"]).issubset({"lexical", "graph"})
+
+    def test_trace_available_for_failed_recall(self, tmp_path):
+        store = _seed_store(tmp_path)
+        retriever = FactRetriever(store=store)
+
+        payload = retriever.search_with_trace(
+            "nonexistent memory topic xyz123",
+            limit=3,
+            lanes=["lexical", "semantic", "graph", "temporal"],
+        )
+
+        assert payload["results"] == []
+        assert payload["trace"]["fused_count"] == 0
+        assert payload["trace"]["lane_hits"]["lexical"] == 0
+        assert payload["trace"]["lane_hits"]["semantic"] == 0
+
+    def test_benchmark_prompt_matrix_shows_gain_over_baseline(self, tmp_path):
+        store = _seed_store(tmp_path)
+        retriever = FactRetriever(store=store)
+        report = retriever.benchmark_prompt_matrix(_fixture()["queries"], limit=3)
+
+        assert report["fused_top1_hits"] > report["baseline_top1_hits"]
+        assert report["improvement"] > 0
+
+        rendered = format_benchmark_report(report)
+        assert "Prompt matrix benchmark" in rendered
+        assert "semantic_alias_graph" in rendered
+        assert "improvement" in rendered.lower()
+
+
+class TestHolographicProviderTrace:
+    def test_prefetch_records_trace_and_trace_action_returns_it(self, tmp_path):
+        provider = HolographicMemoryProvider(
+            config={
+                "db_path": str(tmp_path / "provider.db"),
+                "retrieval_lanes": ["lexical", "semantic", "graph", "temporal"],
+                "enable_rerank": True,
+            }
+        )
+        provider.initialize("test-session")
+
+        seed_store = _seed_store(tmp_path / "seed")
+        rows = seed_store.list_facts(min_trust=0.0, limit=20)
+        for row in rows:
+            provider._store.add_fact(row["content"], category=row["category"], tags=row.get("tags", ""))
+            if row["content"].startswith("The provider is anthropic"):
+                provider._store._conn.execute(
+                    "UPDATE facts SET created_at = ?, updated_at = ? WHERE content = ?",
+                    ("2026-01-01T00:00:00Z", "2026-01-01T00:00:00Z", row["content"]),
+                )
+            elif row["content"].startswith("Correction: the provider is mimo"):
+                provider._store._conn.execute(
+                    "UPDATE facts SET created_at = ?, updated_at = ? WHERE content = ?",
+                    ("2026-04-20T00:00:00Z", "2026-04-20T00:00:00Z", row["content"]),
+                )
+        provider._store._conn.commit()
+
+        block = provider.prefetch("What provider should we use?")
+        assert "Holographic Memory" in block
+        assert "mimo-v2-pro" in block
+
+        trace_payload = json.loads(provider.handle_tool_call("fact_store", {"action": "trace"}))
+        assert trace_payload["trace"]["query"] == "What provider should we use?"
+        assert trace_payload["trace"]["rerank_applied"] in {True, False}
+        assert trace_payload["trace"]["lane_hits"]["temporal"] >= 1
--- a/tests/test_tool_call_benchmark.py
+++ b/tests/test_tool_call_benchmark.py
@@ -1,115 +0,0 @@
-"""Tests for Issue #796 tool-calling benchmark coverage and reporting."""
-
-import sys
-from pathlib import Path
-from types import SimpleNamespace
-from unittest.mock import patch
-
-sys.path.insert(0, str(Path(__file__).parent.parent / "benchmarks"))
-
-from tool_call_benchmark import (  # noqa: E402
-    CallResult,
-    DEFAULT_COMPARE_MODELS,
-    ISSUE_796_CATEGORY_COUNTS,
-    ToolCall,
-    generate_report,
-    run_single_test,
-    suite_category_counts,
-)
-
-
-def test_suite_counts_match_issue_796_distribution():
-    counts = suite_category_counts()
-    assert counts == ISSUE_796_CATEGORY_COUNTS
-    assert sum(counts.values()) == 100
-
-
-def test_default_compare_models_cover_issue_796_lanes():
-    assert len(DEFAULT_COMPARE_MODELS) == 3
-    assert any("gemma-4-31b" in spec for spec in DEFAULT_COMPARE_MODELS)
-    assert any("gemma-4-26b" in spec for spec in DEFAULT_COMPARE_MODELS)
-    assert any("mimo-v2-pro" in spec for spec in DEFAULT_COMPARE_MODELS)
-
-
-def test_generate_report_includes_parallel_and_cost_metrics(tmp_path):
-    output_path = tmp_path / "report.md"
-    results = [
-        CallResult(
-            test_id="file-01",
-            category="file",
-            model="gemma-4-31b",
-            prompt="Read the file.",
-            expected_tool="read_file",
-            success=True,
-            tool_called="read_file",
-            schema_ok=True,
-            tool_args_valid=True,
-            execution_ok=True,
-            tool_count=2,
-            parallel_ok=True,
-            latency_s=1.25,
-            total_tokens=123,
-            estimated_cost_usd=0.0012,
-            cost_status="estimated",
-        ),
-        CallResult(
-            test_id="web-01",
-            category="web",
-            model="mimo-v2-pro",
-            prompt="Search the web.",
-            expected_tool="web_search",
-            success=False,
-            tool_called="web_search",
-            schema_ok=True,
-            tool_args_valid=False,
-            execution_ok=False,
-            tool_count=1,
-            parallel_ok=False,
-            latency_s=2.5,
-            error="bad args",
-            total_tokens=456,
-            estimated_cost_usd=None,
-            cost_status="unknown",
-            skipped=True,
-            skip_reason="web_search unavailable",
-        ),
-    ]
-
-    report = generate_report(results, ["gemma-4-31b", "mimo-v2-pro"], output_path)
-
-    assert output_path.exists()
-    assert "Parallel tool success" in report
-    assert "Avg token cost per call (USD)" in report
-    assert "Skipped / unavailable" in report
-    assert "Requested category mix" in report
-
-
-def test_run_single_test_skips_when_expected_tool_unavailable():
-    class FakeAgent:
-        def __init__(self, *args, **kwargs):
-            self.valid_tool_names = {"read_file", "terminal"}
-            self.session_input_tokens = 0
-            self.session_output_tokens = 0
-            self.session_cache_read_tokens = 0
-            self.session_cache_write_tokens = 0
-            self.session_api_calls = 0
-            self.base_url = ""
-            self.api_key = None
-
-        def run_conversation(self, *args, **kwargs):
-            raise AssertionError("run_conversation should not be called for unavailable tools")
-
-    tc = ToolCall(
-        id="mcp-01",
-        category="mcp",
-        prompt="Use an MCP tool to list resources.",
-        expected_tool="",
-        expected_tool_prefix="mcp_",
-    )
-
-    with patch.dict(sys.modules, {"run_agent": SimpleNamespace(AIAgent=FakeAgent)}):
-        result = run_single_test(tc, "gemini:gemma-4-31b-it", "gemini")
-
-    assert result.skipped is True
-    assert "mcp_" in result.skip_reason
-    assert result.success is False