refactor: nuke legacy harness, drop sdk_ prefixes

The SDK harness is the only path now; legacy host-side code is gone.
File names no longer carry the ``sdk_`` distinction.

Deleted legacy host-side modules:
- strix/agents/StrixAgent/ (template moved to strix/agents/prompts/)
- strix/agents/base_agent.py, state.py
- strix/llm/llm.py, config.py
- strix/runtime/docker_runtime.py, runtime.py
- strix/tools/executor.py, agents_graph/agents_graph_actions.py
- strix/interface/sdk_dispatch.py + the env-flag dispatch in cli.py

Renamed (drop ``sdk_`` prefix):
- strix/sdk_entry.py → strix/entry.py
- strix/agents/sdk_factory.py → strix/agents/factory.py
- strix/agents/sdk_prompt.py → strix/agents/prompt.py
- strix/tools/<x>/<x>_sdk_tool[s].py → strix/tools/<x>/tool[s].py
- strix/tools/_legacy_adapter.py → strix/tools/_state_adapter.py
- ``_legacy`` aliases inside the wrappers → ``_impl``

CLI + TUI now call ``run_strix_scan`` directly — they build the
sandbox image / sources_path locally and rely on
``session_manager.cleanup`` (called inside ``run_strix_scan``'s finally)
for teardown. Three TUI handlers that reached into legacy multi-agent
globals (``_agent_instances``, ``send_user_message_to_agent``,
``stop_agent``) are now no-ops with a TODO; reconnecting them to the
``AgentMessageBus`` is a follow-up.

Tracer.get_total_llm_stats no longer reaches into the deleted
``agents_graph_actions`` globals — the orchestration hooks now feed the
tracer via ``Tracer.record_llm_usage`` (live + completed buckets).
finish_scan's ``_check_active_agents`` and load_skill's runtime
``_agent_instances`` reach-in are no-op stubs; the
``AgentMessageBus`` is the source of truth post-migration.

llm/utils.py rewritten to keep only the streaming-parser helpers
(``normalize_tool_format``, ``parse_tool_invocations``,
``fix_incomplete_tool_call``, ``format_tool_call``, ``clean_content``).
``STRIX_MODEL_MAP`` moved to ``llm/multi_provider_setup.py`` (its only
remaining caller).

Per-file ruff ignores added for legacy interface modules (TUI / main /
CLI / utils / streaming_parser / tool_components) and tracer.py —
pre-existing PLC0415/BLE001/PLR0915 patterns are out of scope.

Tests: 287/287 passing. Renamed test files to drop ``sdk_`` prefix.
``test_tracer.py::test_get_total_llm_stats_aggregates_live_and_completed``
rewritten to feed ``Tracer.record_llm_usage`` instead of legacy globals.
Test file annotations added so pre-commit's strict mypy passes.

strix/tools/reporting/tool.py

@@ -0,0 +1,90 @@
+"""SDK function-tool wrapper for the legacy ``create_vulnerability_report``.
+
+One tool. Local execution (``sandbox_execution=False`` in the legacy
+registration). The legacy implementation handles XML parsing for the
+CVSS breakdown and code locations, runs LLM-based dedup against
+existing reports through ``strix.llm.dedupe.check_duplicate``, and
+persists via ``get_global_tracer().add_vulnerability_report``.
+
+We wrap the synchronous legacy function in ``asyncio.to_thread`` because
+the dedup check makes a network call and we don't want to block the
+event loop while it waits.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any
+
+from agents import RunContextWrapper
+
+from strix.tools._decorator import strix_tool
+from strix.tools.reporting import reporting_actions as _impl
+
+
+def _dump(result: dict[str, Any]) -> str:
+    return json.dumps(result, ensure_ascii=False, default=str)
+
+
+# Generous timeout: the dedup check makes a separate LLM call, and large
+# scans can have many existing reports to compare against.
+@strix_tool(timeout=180)
+async def create_vulnerability_report(
+    ctx: RunContextWrapper,
+    title: str,
+    description: str,
+    impact: str,
+    target: str,
+    technical_analysis: str,
+    poc_description: str,
+    poc_script_code: str,
+    remediation_steps: str,
+    cvss_breakdown: str,
+    endpoint: str | None = None,
+    method: str | None = None,
+    cve: str | None = None,
+    cwe: str | None = None,
+    code_locations: str | None = None,
+) -> str:
+    """File a vulnerability report against the active scan.
+
+    The report is dedup-checked against existing reports (LLM-based
+    similarity); if it's a near-duplicate, the call returns a
+    ``duplicate_of`` pointer instead of creating a new entry.
+
+    Args:
+        title: Short headline (e.g. ``"Reflected XSS in /search?q="``).
+        description: What the vuln is.
+        impact: Concrete impact statement.
+        target: Affected URL / host / service.
+        technical_analysis: How it works.
+        poc_description: Reproduction summary.
+        poc_script_code: Working PoC (curl, python, etc.).
+        remediation_steps: Recommended fix.
+        cvss_breakdown: CVSS 3.1 vector parameters as XML (legacy schema).
+        endpoint: Optional endpoint path.
+        method: Optional HTTP method.
+        cve: Optional CVE identifier.
+        cwe: Optional CWE identifier.
+        code_locations: Optional XML list of file/line references.
+    """
+    return _dump(
+        await asyncio.to_thread(
+            _impl.create_vulnerability_report,
+            title=title,
+            description=description,
+            impact=impact,
+            target=target,
+            technical_analysis=technical_analysis,
+            poc_description=poc_description,
+            poc_script_code=poc_script_code,
+            remediation_steps=remediation_steps,
+            cvss_breakdown=cvss_breakdown,
+            endpoint=endpoint,
+            method=method,
+            cve=cve,
+            cwe=cwe,
+            code_locations=code_locations,
+        ),
+    )