Open-source AI penetration testing tool to find and fix your app’s vulnerabilities.
Python agentsai-hackingai-penetration-testingai-pentestingai-securityartificial-intelligencebug-bountycode-qualityctf-toolscybersecuritycybersecurity-toolsethical-hackinghackingllm-securityoffensive-securitypenetration-testingpentesting-toolsred-teamingsecuritysecurity-automation
Simplify SDK-native orchestration
0xallambd40884fcff3
diff --git a/pyproject.toml b/pyproject.tomlindex 87cb0abb..b06371d6 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -194,11 +194,6 @@ ignore = ["strix/tools/**/*.py" = ["ARG001", # Unused function argument (tools may have unused args for interface consistency)]-# SDK lifecycle hooks have a fixed signature — unused args are part of the contract.-"strix/orchestration/hooks.py" = [- "ARG002", # Unused method argument (RunHooks signature is set by SDK)- "TC002", # ModelResponse, RunContextWrapper, AgentHookContext are annotation-only-]# Anthropic cache wrapper inherits from LitellmModel; signature shadows builtin `input`."strix/llm/anthropic_cache_wrapper.py" = ["A002", # Argument shadows builtin (parent signature uses `input`)@@ -209,9 +204,6 @@ ignore = [# Backend factories import their backend's deps lazily so deployments# that pick a different backend don't need every backend's libs installed."strix/runtime/backends.py" = ["PLC0415"]-# The vulnerability MD renderer is a long monolithic format function;-# splitting per-section would obscure the structure without simplifying.-"strix/telemetry/scan_artifacts.py" = ["PLR0912", "PLR0915", "PERF401"]"strix/runtime/docker_client.py" = ["TC002", # Manifest, Container imported for annotations"TC003", # uuid imported for annotation@@ -234,13 +226,13 @@ ignore = ["strix/agents/factory.py" = ["TC002"]# Entry point: ``Path`` is used at runtime by the typing of the# session_manager call; importing under TYPE_CHECKING would defer-# resolution past where mypy needs it. ``_build_root_task`` legitimately+# resolution past where mypy needs it. ``build_root_task`` legitimately# walks every supported target type — splitting it into per-type# helpers would add indirection without simplifying anything.-"strix/orchestration/scan.py" = ["TC003", "PLR0912", "PLR0915", "PLC0415"]-# Tracer carries a long event surface and a runtime ``Callable``-# annotation on ``vulnerability_found_callback``.-"strix/telemetry/tracer.py" = ["TC003", "PLR0912", "PLR0915", "E501"]+"strix/orchestration/runner.py" = ["TC003", "PLR0912", "PLR0915", "PLC0415"]+# ScanStore carries scan artifact/report fields, artifact rendering, and+# a runtime ``Callable`` annotation on ``vulnerability_found_callback``.+"strix/telemetry/scan_store.py" = ["TC003", "PLR0912", "PLR0915", "E501", "PERF401"]# Interface utility branches per scope-mode / target-type combination;# splitting would obscure the decision tree without simplifying it."strix/interface/utils.py" = ["PLR0912", "BLE001", "PLC0415"]@@ -249,7 +241,6 @@ ignore = ["strix/interface/cli.py" = ["BLE001", "PLC0415"]"strix/interface/tui.py" = ["BLE001", "PLC0415", "PLR0912", "PLR0915", "SIM105"]"strix/interface/main.py" = ["BLE001", "PLC0415", "PLR0912", "PLR0915"]-"strix/interface/streaming_parser.py" = ["PLC0415"]"strix/interface/tool_components/agent_message_renderer.py" = ["PLC0415"][tool.ruff.lint.isort]diff --git a/strix.spec b/strix.specindex 425219ad..445988ef 100644--- a/strix.spec+++ b/strix.spec@@ -119,23 +119,37 @@ hiddenimports = ['strix.interface.utils','strix.interface.tool_components','strix.agents',- 'strix.agents.base_agent',- 'strix.agents.state',- 'strix.agents.StrixAgent',+ 'strix.agents.factory',+ 'strix.agents.prompt','strix.llm',- 'strix.llm.llm',- 'strix.llm.config',- 'strix.llm.utils',- 'strix.llm.memory_compressor',+ 'strix.llm.anthropic_cache_wrapper',+ 'strix.llm.dedupe',+ 'strix.llm.multi_provider_setup',+ 'strix.llm.retry',+ 'strix.orchestration',+ 'strix.orchestration.coordinator',+ 'strix.orchestration.runner',+ 'strix.orchestration.utils','strix.runtime',- 'strix.runtime.runtime',- 'strix.runtime.docker_runtime',+ 'strix.runtime.backends',+ 'strix.runtime.caido_bootstrap',+ 'strix.runtime.docker_client',+ 'strix.runtime.session_manager','strix.telemetry',- 'strix.telemetry.tracer',+ 'strix.telemetry.logging',+ 'strix.telemetry.posthog',+ 'strix.telemetry.scan_store','strix.tools',- 'strix.tools.registry',- 'strix.tools.executor',- 'strix.tools.argument_parser',+ 'strix.tools.agents_graph.tools',+ 'strix.tools.finish.tool',+ 'strix.tools.notes.tools',+ 'strix.tools.proxy._calls',+ 'strix.tools.proxy.tools',+ 'strix.tools.python.tool',+ 'strix.tools.reporting.tool',+ 'strix.tools.thinking.tool',+ 'strix.tools.todo.tools',+ 'strix.tools.web_search.tool','strix.skills',]diff --git a/strix/agents/factory.py b/strix/agents/factory.pyindex 54aeb0fe..50ec0e26 100644--- a/strix/agents/factory.py+++ b/strix/agents/factory.py@@ -29,7 +29,6 @@ from agents.tool import Toolfrom strix.agents.prompt import render_system_promptfrom strix.tools.agents_graph.tools import (agent_finish,- agent_status,create_agent,send_message_to_agent,stop_agent,@@ -163,7 +162,6 @@ _BASE_TOOLS: tuple[Tool, ...] = (python_action,# Multi-agent graph tools (the coordinator is in ctx.context)view_agent_graph,- agent_status,send_message_to_agent,wait_for_message,create_agent,diff --git a/strix/interface/cli.py b/strix/interface/cli.pyindex 48462417..acdcbbb4 100644--- a/strix/interface/cli.py+++ b/strix/interface/cli.py@@ -13,9 +13,9 @@ from rich.panel import Panelfrom rich.text import Textfrom strix.config import load_settings-from strix.orchestration.scan import run_strix_scan+from strix.orchestration.runner import run_strix_scanfrom strix.runtime import session_manager-from strix.telemetry.tracer import Tracer, set_global_tracer+from strix.telemetry.scan_store import ScanStore, set_global_scan_storefrom .utils import (build_live_stats_text,@@ -95,8 +95,9 @@ async def run_cli(args: Any) -> None: # noqa: PLR0915"resume_instruction": getattr(args, "user_explicit_instruction", None) or "",}- tracer = Tracer(args.run_name)- tracer.set_scan_config(scan_config)+ scan_store = ScanStore(args.run_name)+ scan_store.set_scan_config(scan_config)+ scan_store.hydrate_from_run_dir()def display_vulnerability(report: dict[str, Any]) -> None:report_id = report.get("id", "unknown")@@ -114,13 +115,13 @@ async def run_cli(args: Any) -> None: # noqa: PLR0915console.print(vuln_panel)console.print()- tracer.vulnerability_found_callback = display_vulnerability+ scan_store.vulnerability_found_callback = display_vulnerabilitydef cleanup_on_exit() -> None:- tracer.cleanup()+ scan_store.cleanup()def signal_handler(_signum: int, _frame: Any) -> None:- tracer.cleanup()+ scan_store.cleanup()sys.exit(1)atexit.register(cleanup_on_exit)@@ -129,14 +130,14 @@ async def run_cli(args: Any) -> None: # noqa: PLR0915if hasattr(signal, "SIGHUP"):signal.signal(signal.SIGHUP, signal_handler)- set_global_tracer(tracer)+ set_global_scan_store(scan_store)def create_live_status() -> Panel:status_text = Text()status_text.append("Penetration test in progress", style="bold #22c55e")status_text.append("\n\n")- stats_text = build_live_stats_text(tracer)+ stats_text = build_live_stats_text(scan_store)if stats_text:status_text.append(stats_text)@@ -179,7 +180,6 @@ async def run_cli(args: Any) -> None: # noqa: PLR0915scan_id=args.run_name,image=_resolve_sandbox_image(),local_sources=getattr(args, "local_sources", None) or [],- tracer=tracer,interactive=bool(getattr(args, "interactive", False)),)finally:@@ -196,7 +196,7 @@ async def run_cli(args: Any) -> None: # noqa: PLR0915console.print(f"[bold red]Error during penetration test:[/] {e}")raise- if tracer.final_scan_result:+ if scan_store.final_scan_result:console.print()final_report_text = Text()@@ -206,7 +206,7 @@ async def run_cli(args: Any) -> None: # noqa: PLR0915Text.assemble(final_report_text,"\n\n",- tracer.final_scan_result,+ scan_store.final_scan_result,),title="[bold white]STRIX",title_align="left",diff --git a/strix/interface/main.py b/strix/interface/main.pyindex b500b5a0..bc37a35b 100644--- a/strix/interface/main.py+++ b/strix/interface/main.py@@ -37,7 +37,7 @@ from strix.interface.utils import (validate_llm_response,)from strix.telemetry import posthog-from strix.telemetry.tracer import get_global_tracer+from strix.telemetry.scan_store import get_global_scan_storeHOST_GATEWAY_HOSTNAME = "host.docker.internal"@@ -47,7 +47,7 @@ import logging # noqa: E402# Per-scan logging is set up by ``setup_scan_logging`` from inside-# ``orchestration.scan.run_strix_scan`` once the scan ``run_dir`` is+# ``orchestration.runner.run_strix_scan`` once the scan ``run_dir`` is# known — that's where ``strix.*`` levels and handlers are owned. Pre-scan# work (``main()``, env validation, image pull) emits via the module# logger; once setup_scan_logging runs, those records start landing in@@ -552,11 +552,11 @@ def _load_resume_state(args: argparse.Namespace, parser: argparse.ArgumentParserdef display_completion_message(args: argparse.Namespace, results_path: Path) -> None:console = Console()- tracer = get_global_tracer()+ scan_store = get_global_scan_store()scan_completed = False- if tracer and tracer.scan_results:- scan_completed = tracer.scan_results.get("scan_completed", False)+ if scan_store and scan_store.scan_results:+ scan_completed = scan_store.scan_results.get("scan_completed", False)completion_text = Text()if scan_completed:@@ -575,7 +575,7 @@ def display_completion_message(args: argparse.Namespace, results_path: Path) ->target_text.append("\n ")target_text.append(target_info["original"], style="white")- stats_text = build_final_stats_text(tracer)+ stats_text = build_final_stats_text(scan_store)panel_parts: list[Text | str] = [completion_text, "\n\n", target_text]@@ -753,16 +753,16 @@ def main() -> None:posthog.error("unhandled_exception", str(e))raisefinally:- tracer = get_global_tracer()- if tracer:- posthog.end(tracer, exit_reason=exit_reason)+ scan_store = get_global_scan_store()+ if scan_store:+ posthog.end(scan_store, exit_reason=exit_reason)results_path = Path("strix_runs") / args.run_namedisplay_completion_message(args, results_path)if args.non_interactive:- tracer = get_global_tracer()- if tracer and tracer.vulnerability_reports:+ scan_store = get_global_scan_store()+ if scan_store and scan_store.vulnerability_reports:sys.exit(2)diff --git a/strix/interface/tui.py b/strix/interface/tui.pyindex 0b0ba092..fb9a7d2c 100644--- a/strix/interface/tui.py+++ b/strix/interface/tui.py@@ -2,13 +2,16 @@ import argparseimport asyncioimport atexitimport contextlib+import jsonimport loggingimport signalimport sysimport threadingfrom collections.abc import Callable+from datetime import UTC, datetimefrom importlib.metadata import PackageNotFoundErrorfrom importlib.metadata import version as pkg_version+from pathlib import Pathfrom typing import TYPE_CHECKING, Any, ClassVar@@ -31,12 +34,11 @@ from textual.widgets.tree import TreeNodefrom strix.config import load_settingsfrom strix.interface.tool_components.agent_message_renderer import AgentMessageRenderer-from strix.interface.tool_components.registry import get_tool_rendererfrom strix.interface.tool_components.user_message_renderer import UserMessageRendererfrom strix.interface.utils import build_tui_stats_text-from strix.orchestration.scan import run_strix_scan+from strix.orchestration.runner import run_strix_scanfrom strix.runtime import session_manager-from strix.telemetry.tracer import Tracer, set_global_tracer+from strix.telemetry.scan_store import ScanStore, set_global_scan_storelogger = logging.getLogger(__name__)@@ -639,6 +641,139 @@ class VulnerabilitiesPanel(VerticalScroll): # type: ignore[misc]self.mount(item)+class TuiLiveView:+ """UI-owned projection of coordinator state and SDK session items."""++ def __init__(self) -> None:+ self.agents: dict[str, dict[str, Any]] = {}+ self.chat_messages: list[dict[str, Any]] = []+ self._next_message_id = 1+ self._session_message_keys: dict[tuple[str, int], dict[str, Any]] = {}++ def hydrate_from_run_dir(self, run_dir: Path) -> None:+ agents_path = run_dir / "agents.json"+ if not agents_path.exists():+ return+ try:+ agents_data = json.loads(agents_path.read_text(encoding="utf-8"))+ except (OSError, json.JSONDecodeError):+ return+ statuses = agents_data.get("statuses") or {}+ names = agents_data.get("names") or {}+ parent_of = agents_data.get("parent_of") or {}+ if not isinstance(statuses, dict):+ return+ for agent_id, status in statuses.items():+ if not isinstance(agent_id, str):+ continue+ self.upsert_agent(+ agent_id,+ name=names.get(agent_id, agent_id) if isinstance(names, dict) else agent_id,+ parent_id=parent_of.get(agent_id) if isinstance(parent_of, dict) else None,+ status=str(status),+ )++ def upsert_agent(+ self,+ agent_id: str,+ *,+ name: str | None = None,+ parent_id: str | None = None,+ status: str | None = None,+ error_message: str | None = None,+ ) -> None:+ now = datetime.now(UTC).isoformat()+ current = self.agents.setdefault(+ agent_id,+ {+ "id": agent_id,+ "name": name or agent_id,+ "parent_id": parent_id,+ "status": status or "running",+ "created_at": now,+ "updated_at": now,+ },+ )+ if name is not None:+ current["name"] = name+ if parent_id is not None or "parent_id" not in current:+ current["parent_id"] = parent_id+ if status is not None:+ current["status"] = status+ if error_message:+ current["error_message"] = error_message+ current["updated_at"] = now++ def sync_agent_messages_from_items(self, agent_id: str, items: list[Any]) -> None:+ other_agents = [m for m in self.chat_messages if m.get("agent_id") != agent_id]+ refreshed: list[dict[str, Any]] = []++ for index, item in enumerate(items):+ converted = _sdk_item_to_chat_message(item)+ if converted is None:+ continue++ key = (agent_id, index)+ existing = self._session_message_keys.get(key)+ if existing is None:+ existing = {+ "message_id": self._next_message_id,+ "timestamp": datetime.now(UTC).isoformat(),+ }+ self._next_message_id += 1+ self._session_message_keys[key] = existing++ refreshed.append(+ {+ "message_id": existing["message_id"],+ "content": converted["content"],+ "role": converted["role"],+ "agent_id": agent_id,+ "timestamp": existing["timestamp"],+ "metadata": {"source": "sdk_session", "session_index": index},+ }+ )++ self.chat_messages = other_agents + refreshed+++def _sdk_item_to_chat_message(item: Any) -> dict[str, str] | None:+ if not isinstance(item, dict):+ if hasattr(item, "model_dump"):+ item = item.model_dump(exclude_unset=True)+ else:+ return None++ role = item.get("role")+ if role not in {"user", "assistant"}:+ return None++ content = _extract_sdk_text(item.get("content"))+ if not content:+ return None+ return {"role": str(role), "content": content}+++def _extract_sdk_text(content: Any) -> str:+ if isinstance(content, str):+ return content+ if isinstance(content, list):+ parts: list[str] = []+ for part in content:+ if isinstance(part, str):+ parts.append(part)+ elif isinstance(part, dict):+ text = part.get("text") or part.get("content")+ if isinstance(text, str):+ parts.append(text)+ else:+ text = getattr(part, "text", None) or getattr(part, "content", None)+ if isinstance(text, str):+ parts.append(text)+ return "\n".join(p for p in parts if p)+ return ""++class QuitScreen(ModalScreen): # type: ignore[misc]def compose(self) -> ComposeResult:yield Grid(@@ -704,9 +839,13 @@ class StrixTUIApp(App): # type: ignore[misc]self.args = argsself.scan_config = self._build_scan_config(args)- self.tracer = Tracer(self.scan_config["run_name"])- self.tracer.set_scan_config(self.scan_config)- set_global_tracer(self.tracer)+ self.scan_store = ScanStore(self.scan_config["run_name"])+ self.scan_store.set_scan_config(self.scan_config)+ self.scan_store.hydrate_from_run_dir()+ set_global_scan_store(self.scan_store)+ self.live_view = TuiLiveView()+ self.live_view.hydrate_from_run_dir(self.scan_store.get_run_dir())+ self._live_sync_future: Any | None = None# Pre-create the coordinator here so the TUI can route stop/chat# commands while the scan loop runs in a worker thread.@@ -759,10 +898,10 @@ class StrixTUIApp(App): # type: ignore[misc]def _setup_cleanup_handlers(self) -> None:def cleanup_on_exit() -> None:- self.tracer.cleanup()+ self.scan_store.cleanup()def signal_handler(_signum: int, _frame: Any) -> None:- self.tracer.cleanup()+ self.scan_store.cleanup()sys.exit(0)atexit.register(cleanup_on_exit)@@ -881,9 +1020,9 @@ class StrixTUIApp(App): # type: ignore[misc]self._start_scan_thread()- self.set_interval(0.35, self._update_ui_from_tracer)+ self.set_interval(0.35, self._update_ui)- def _update_ui_from_tracer(self) -> None:+ def _update_ui(self) -> None:if self.show_splash:return@@ -902,8 +1041,10 @@ class StrixTUIApp(App): # type: ignore[misc]except (ValueError, Exception):return+ self._sync_live_view()+agent_updates = False- for agent_id, agent_data in list(self.tracer.agents.items()):+ for agent_id, agent_data in list(self.live_view.agents.items()):if agent_id not in self._displayed_agents:self._add_agent_node(agent_data)self._displayed_agents.add(agent_id)@@ -922,6 +1063,43 @@ class StrixTUIApp(App): # type: ignore[misc]self._update_vulnerabilities_panel()+ def _sync_live_view(self) -> None:+ future = self._live_sync_future+ if future is not None:+ if not future.done():+ if self._scan_loop is not None and self._scan_loop.is_closed():+ future.cancel()+ self._live_sync_future = None+ else:+ return+ else:+ self._live_sync_future = None+ try:+ parent_of, statuses, names, session_items = future.result()+ except Exception:+ logger.exception("TUI live-view sync failed")+ else:+ for agent_id, status in statuses.items():+ self.live_view.upsert_agent(+ agent_id,+ name=names.get(agent_id, agent_id),+ parent_id=parent_of.get(agent_id),+ status=status,+ )+ for agent_id, items in session_items.items():+ self.live_view.sync_agent_messages_from_items(agent_id, items)+ if self._scan_loop is None or self._scan_loop.is_closed():+ return++ async def collect() -> tuple[+ dict[str, str | None], dict[str, Any], dict[str, str], dict[str, list[Any]]+ ]:+ parent_of, statuses, names = await self.coordinator.graph_snapshot()+ session_items = await self.coordinator.session_items_snapshot()+ return parent_of, statuses, names, session_items++ self._live_sync_future = asyncio.run_coroutine_threadsafe(collect(), self._scan_loop)+def _update_agent_node(self, agent_id: str, agent_data: dict[str, Any]) -> bool:if agent_id not in self.agent_nodes:return False@@ -937,7 +1115,6 @@ class StrixTUIApp(App): # type: ignore[misc]"completed": "🟢","failed": "🔴","stopped": "■",- "llm_failed": "🔴",}status_icon = status_indicators.get(status, "○")@@ -1074,8 +1251,6 @@ class StrixTUIApp(App): # type: ignore[misc]if event["type"] == "chat":content = self._render_chat_content(event["data"])- elif event["type"] == "tool":- content = self._render_tool_content_simple(event["data"])if content:if renderables:@@ -1090,7 +1265,7 @@ class StrixTUIApp(App): # type: ignore[misc]return self._merge_renderables(renderables)- def _get_status_display_content( # noqa: PLR0911+ def _get_status_display_content(self, agent_id: str, agent_data: dict[str, Any]) -> tuple[Text | None, Text, bool]:status = agent_data.get("status", "running")@@ -1116,18 +1291,6 @@ class StrixTUIApp(App): # type: ignore[misc]text.append(msg)return (text, Text(), False)- if status == "llm_failed":- error_msg = agent_data.get("error_message", "")- text = Text()- if error_msg:- text.append(error_msg, style="red")- else:- text.append("LLM request failed", style="red")- self._stop_dot_animation()- keymap = Text()- keymap.append("Send message to retry", style="dim")- return (text, keymap, False)-if status == "failed":error_msg = agent_data.get("error_message", "")text = Text()@@ -1173,7 +1336,7 @@ class StrixTUIApp(App): # type: ignore[misc]returntry:- agent_data = self.tracer.agents[self.selected_agent_id]+ agent_data = self.live_view.agents[self.selected_agent_id]content, keymap, should_animate = self._get_status_display_content(self.selected_agent_id, agent_data)@@ -1206,7 +1369,7 @@ class StrixTUIApp(App): # type: ignore[misc]stats_content = Text()- stats_text = build_tui_stats_text(self.tracer)+ stats_text = build_tui_stats_text(self.scan_store)if stats_text:stats_content.append(stats_text)@@ -1225,7 +1388,7 @@ class StrixTUIApp(App): # type: ignore[misc]if not self._is_widget_safe(vuln_panel):return- vulnerabilities = self.tracer.vulnerability_reports+ vulnerabilities = self.scan_store.vulnerability_reportsif not vulnerabilities:self._safe_widget_operation(vuln_panel.add_class, "hidden")@@ -1234,8 +1397,10 @@ class StrixTUIApp(App): # type: ignore[misc]enriched_vulns = []for vuln in vulnerabilities:enriched = dict(vuln)- report_id = vuln.get("id", "")- agent_name = self._get_agent_name_for_vulnerability(report_id)+ agent_name = enriched.get("agent_name")+ agent_id = enriched.get("agent_id")+ if not agent_name and isinstance(agent_id, str):+ agent_name = self._get_agent_name(agent_id)if agent_name:enriched["agent_name"] = agent_nameenriched_vulns.append(enriched)@@ -1243,18 +1408,6 @@ class StrixTUIApp(App): # type: ignore[misc]self._safe_widget_operation(vuln_panel.remove_class, "hidden")vuln_panel.update_vulnerabilities(enriched_vulns)- def _get_agent_name_for_vulnerability(self, report_id: str) -> str | None:- """Find the agent name that created a vulnerability report."""- for _exec_id, tool_data in list(self.tracer.tool_executions.items()):- if tool_data.get("tool_name") == "create_vulnerability_report":- result = tool_data.get("result", {})- if isinstance(result, dict) and result.get("report_id") == report_id:- agent_id = tool_data.get("agent_id")- if agent_id and agent_id in self.tracer.agents:- name: str = self.tracer.agents[agent_id].get("name", "Unknown Agent")- return name- return None-def _get_sweep_animation(self, color_palette: list[str]) -> Text:text = Text()num_squares = self._sweep_num_squares@@ -1307,8 +1460,8 @@ class StrixTUIApp(App): # type: ignore[misc]def _animate_dots(self) -> None:has_active_agents = False- if self.selected_agent_id and self.selected_agent_id in self.tracer.agents:- agent_data = self.tracer.agents[self.selected_agent_id]+ if self.selected_agent_id and self.selected_agent_id in self.live_view.agents:+ agent_data = self.live_view.agents[self.selected_agent_id]status = agent_data.get("status", "running")if status in ["running", "waiting"]:has_active_agents = True@@ -1323,7 +1476,7 @@ class StrixTUIApp(App): # type: ignore[misc]if not has_active_agents:has_active_agents = any(agent_data.get("status", "running") in ["running", "waiting"]- for agent_data in self.tracer.agents.values()+ for agent_data in self.live_view.agents.values())if not has_active_agents:@@ -1331,28 +1484,12 @@ class StrixTUIApp(App): # type: ignore[misc]self._spinner_frame_index = 0def _agent_has_real_activity(self, agent_id: str) -> bool:- initial_tools = {"scan_start_info", "subagent_start_info"}-- for _exec_id, tool_data in list(self.tracer.tool_executions.items()):- if tool_data.get("agent_id") == agent_id:- tool_name = tool_data.get("tool_name", "")- if tool_name not in initial_tools:- return True-- return False+ return any(msg.get("agent_id") == agent_id for msg in self.live_view.chat_messages)def _agent_vulnerability_count(self, agent_id: str) -> int:- count = 0- for _exec_id, tool_data in list(self.tracer.tool_executions.items()):- if tool_data.get("agent_id") == agent_id:- tool_name = tool_data.get("tool_name", "")- if tool_name == "create_vulnerability_report":- status = tool_data.get("status", "")- if status == "completed":- result = tool_data.get("result", {})- if isinstance(result, dict) and result.get("success"):- count += 1- return count+ return sum(+ 1 for vuln in self.scan_store.vulnerability_reports if vuln.get("agent_id") == agent_id+ )def _gather_agent_events(self, agent_id: str) -> list[dict[str, Any]]:chat_events = [@@ -1362,24 +1499,12 @@ class StrixTUIApp(App): # type: ignore[misc]"id": f"chat_{msg['message_id']}","data": msg,}- for msg in self.tracer.chat_messages+ for msg in self.live_view.chat_messagesif msg.get("agent_id") == agent_id]- tool_events = [- {- "type": "tool",- "timestamp": tool_data["timestamp"],- "id": f"tool_{exec_id}",- "data": tool_data,- }- for exec_id, tool_data in list(self.tracer.tool_executions.items())- if tool_data.get("agent_id") == agent_id- ]-- events = chat_events + tool_events- events.sort(key=lambda e: (e["timestamp"], e["id"]))- return events+ chat_events.sort(key=lambda e: (e["timestamp"], e["id"]))+ return chat_eventsdef watch_selected_agent_id(self, _agent_id: str | None) -> None:if len(self.screen_stack) > 1 or self.show_splash:@@ -1412,7 +1537,6 @@ class StrixTUIApp(App): # type: ignore[misc]scan_id=self.scan_config["run_name"],image=str(image),local_sources=getattr(self.args, "local_sources", None) or [],- tracer=self.tracer,coordinator=self.coordinator,interactive=True,),@@ -1470,7 +1594,6 @@ class StrixTUIApp(App): # type: ignore[misc]"completed": "🟢","failed": "🔴","stopped": "■",- "llm_failed": "🔴",}status_icon = status_indicators.get(status, "○")@@ -1532,7 +1655,7 @@ class StrixTUIApp(App): # type: ignore[misc]def _copy_node_under(self, node_to_copy: TreeNode, new_parent: TreeNode) -> None:agent_id = node_to_copy.data["agent_id"]- agent_data = self.tracer.agents.get(agent_id, {})+ agent_data = self.live_view.agents.get(agent_id, {})agent_name_raw = agent_data.get("name", "Agent")status = agent_data.get("status", "running")@@ -1542,7 +1665,6 @@ class StrixTUIApp(App): # type: ignore[misc]"completed": "🟢","failed": "🔴","stopped": "■",- "llm_failed": "🔴",}status_icon = status_indicators.get(status, "○")@@ -1567,7 +1689,7 @@ class StrixTUIApp(App): # type: ignore[misc]def _reorganize_orphaned_agents(self, new_parent_id: str) -> None:agents_to_move = []- for agent_id, agent_data in list(self.tracer.agents.items()):+ for agent_id, agent_data in list(self.live_view.agents.items()):if (agent_data.get("parent_id") == new_parent_idand agent_id in self.agent_nodes@@ -1608,71 +1730,6 @@ class StrixTUIApp(App): # type: ignore[misc]return AgentMessageRenderer.render_simple(content)- def _render_tool_content_simple(self, tool_data: dict[str, Any]) -> Any:- tool_name = tool_data.get("tool_name", "Unknown Tool")- args = tool_data.get("args", {})- status = tool_data.get("status", "unknown")- result = tool_data.get("result")-- renderer = get_tool_renderer(tool_name)-- if renderer:- widget = renderer.render(tool_data)- return widget.content-- text = Text()-- if tool_name in ("llm_error_details", "sandbox_error_details"):- return self._render_error_details(text, tool_name, args)-- text.append("→ Using tool ")- text.append(tool_name, style="bold blue")-- status_styles = {- "running": ("●", "yellow"),- "completed": ("✓", "green"),- "failed": ("✗", "red"),- "error": ("✗", "red"),- }- icon, style = status_styles.get(status, ("○", "dim"))- text.append(" ")- text.append(icon, style=style)-- if args:- for k, v in list(args.items())[:5]:- str_v = str(v)- if len(str_v) > 500:- str_v = str_v[:497] + "..."- text.append("\n ")- text.append(k, style="dim")- text.append(": ")- text.append(str_v)-- if status in ["completed", "failed", "error"] and result:- result_str = str(result)- if len(result_str) > 1000:- result_str = result_str[:997] + "..."- text.append("\n")- text.append("Result: ", style="bold")- text.append(result_str)-- return text-- def _render_error_details(self, text: Any, tool_name: str, args: dict[str, Any]) -> Any:- if tool_name == "llm_error_details":- text.append("✗ LLM Request Failed", style="red")- else:- text.append("✗ Sandbox Initialization Failed", style="red")- if args.get("error"):- text.append(f"\n{args['error']}", style="bold red")- if args.get("details"):- details = str(args["details"])- if len(details) > 1000:- details = details[:997] + "..."- text.append("\nDetails: ", style="dim")- text.append(details)- return text-@on(Tree.NodeHighlighted) # type: ignore[misc]def handle_tree_highlight(self, event: Tree.NodeHighlighted) -> None:if len(self.screen_stack) > 1 or self.show_splash:@@ -1718,21 +1775,8 @@ class StrixTUIApp(App): # type: ignore[misc]self.selected_agent_id,len(message),)- if self.tracer:- self.tracer.log_chat_message(- content=message,- role="user",- agent_id=self.selected_agent_id,- )-- # Route to the agent's SDK session. The scan loop runs on a- # worker thread; ``run_coroutine_threadsafe`` submits the- # coroutine onto that loop and returns immediately so the TUI- # stays responsive. After enqueuing the message, request a- # graceful interrupt of the agent's current turn so the user- # input is processed without waiting for the active LLM/tool- # call to finish — the SDK saves the in-flight turn cleanly- # before honoring ``cancel(mode="after_turn")``.+ # Route to the agent's SDK session. The coordinator also interrupts+ # any active stream so the message is picked up on the next run cycle.if self._scan_loop is not None and not self._scan_loop.is_closed():target_agent_id = self.selected_agent_idasyncio.run_coroutine_threadsafe(@@ -1742,10 +1786,6 @@ class StrixTUIApp(App): # type: ignore[misc]),self._scan_loop,)- asyncio.run_coroutine_threadsafe(- self.coordinator.request_interrupt(target_agent_id, mode="after_turn"),- self._scan_loop,- )self._displayed_events.clear()self._update_chat_view()@@ -1754,8 +1794,8 @@ class StrixTUIApp(App): # type: ignore[misc]def _get_agent_name(self, agent_id: str) -> str:try:- if self.tracer and agent_id in self.tracer.agents:- agent_name = self.tracer.agents[agent_id].get("name")+ if agent_id in self.live_view.agents:+ agent_name = self.live_view.agents[agent_id].get("name")if isinstance(agent_name, str):return agent_nameexcept (KeyError, AttributeError) as e:@@ -1822,12 +1862,12 @@ class StrixTUIApp(App): # type: ignore[misc]agent_name = "Unknown Agent"try:- if self.tracer and self.selected_agent_id in self.tracer.agents:- agent_data = self.tracer.agents[self.selected_agent_id]+ if self.selected_agent_id in self.live_view.agents:+ agent_data = self.live_view.agents[self.selected_agent_id]agent_name = agent_data.get("name", "Unknown Agent")agent_status = agent_data.get("status", "running")- if agent_status not in ["running", "waiting", "llm_failed"]:+ if agent_status not in ["running", "waiting"]:return agent_name, Falseagent_events = self._gather_agent_events(self.selected_agent_id)@@ -1862,7 +1902,7 @@ class StrixTUIApp(App): # type: ignore[misc]self._scan_thread.join(timeout=1.0)- self.tracer.cleanup()+ self.scan_store.cleanup()self.exit()diff --git a/strix/interface/utils.py b/strix/interface/utils.pyindex 1acd4a7c..98a8c7de 100644--- a/strix/interface/utils.py+++ b/strix/interface/utils.py@@ -23,16 +23,6 @@ from rich.text import Textfrom strix.config import load_settings-# Token formatting utilities-def format_token_count(count: float) -> str:- count = int(count)- if count >= 1_000_000:- return f"{count / 1_000_000:.1f}M"- if count >= 1_000:- return f"{count / 1_000:.1f}K"- return str(count)--# Display utilitiesdef get_severity_color(severity: str) -> str:severity_colors = {@@ -206,13 +196,13 @@ def format_vulnerability_report(report: dict[str, Any]) -> Text: # noqa: PLR091return text-def _build_vulnerability_stats(stats_text: Text, tracer: Any) -> None:+def _build_vulnerability_stats(stats_text: Text, scan_store: Any) -> None:"""Build vulnerability section of stats text."""- vuln_count = len(tracer.vulnerability_reports)+ vuln_count = len(scan_store.vulnerability_reports)if vuln_count > 0:severity_counts = {"critical": 0, "high": 0, "medium": 0, "low": 0, "info": 0}- for report in tracer.vulnerability_reports:+ for report in scan_store.vulnerability_reports:severity = report.get("severity", "").lower()if severity in severity_counts:severity_counts[severity] += 1@@ -245,63 +235,20 @@ def _build_vulnerability_stats(stats_text: Text, tracer: Any) -> None:stats_text.append("\n")-def _build_llm_stats(stats_text: Text, total_stats: dict[str, Any]) -> None:- """Build LLM usage section of stats text."""- if total_stats["requests"] > 0:- stats_text.append("\n")- stats_text.append("Input Tokens ", style="dim")- stats_text.append(format_token_count(total_stats["input_tokens"]), style="white")-- if total_stats["cached_tokens"] > 0:- stats_text.append(" · ", style="dim white")- stats_text.append("Cached Tokens ", style="dim")- stats_text.append(format_token_count(total_stats["cached_tokens"]), style="white")-- stats_text.append(" · ", style="dim white")- stats_text.append("Output Tokens ", style="dim")- stats_text.append(format_token_count(total_stats["output_tokens"]), style="white")-- if total_stats["cost"] > 0:- stats_text.append(" · ", style="dim white")- stats_text.append("Cost ", style="dim")- stats_text.append(f"${total_stats['cost']:.4f}", style="bold #fbbf24")- else:- stats_text.append("\n")- stats_text.append("Cost ", style="dim")- stats_text.append("$0.0000 ", style="#fbbf24")- stats_text.append("· ", style="dim white")- stats_text.append("Tokens ", style="dim")- stats_text.append("0", style="white")---def build_final_stats_text(tracer: Any) -> Text:- """Build stats text for final output with detailed messages and LLM usage."""+def build_final_stats_text(scan_store: Any) -> Text:+ """Build final stats from Strix-owned scan artifacts."""stats_text = Text()- if not tracer:+ if not scan_store:return stats_text- _build_vulnerability_stats(stats_text, tracer)-- tool_count = tracer.get_real_tool_count()- agent_count = len(tracer.agents)-- stats_text.append("Agents", style="dim")- stats_text.append(" ")- stats_text.append(str(agent_count), style="bold white")- stats_text.append(" · ", style="dim white")- stats_text.append("Tools", style="dim")- stats_text.append(" ")- stats_text.append(str(tool_count), style="bold white")-- llm_stats = tracer.get_total_llm_stats()- _build_llm_stats(stats_text, llm_stats["total"])+ _build_vulnerability_stats(stats_text, scan_store)return stats_text-def build_live_stats_text(tracer: Any) -> Text:+def build_live_stats_text(scan_store: Any) -> Text:stats_text = Text()- if not tracer:+ if not scan_store:return stats_textmodel = load_settings().llm.model or "unknown"@@ -309,16 +256,13 @@ def build_live_stats_text(tracer: Any) -> Text:stats_text.append(str(model), style="white")stats_text.append("\n")- vuln_count = len(tracer.vulnerability_reports)- tool_count = tracer.get_real_tool_count()- agent_count = len(tracer.agents)-+ vuln_count = len(scan_store.vulnerability_reports)stats_text.append("Vulnerabilities ", style="dim")stats_text.append(f"{vuln_count}", style="white")stats_text.append("\n")if vuln_count > 0:severity_counts = {"critical": 0, "high": 0, "medium": 0, "low": 0, "info": 0}- for report in tracer.vulnerability_reports:+ for report in scan_store.vulnerability_reports:severity = report.get("severity", "").lower()if severity in severity_counts:severity_counts[severity] += 1@@ -340,57 +284,18 @@ def build_live_stats_text(tracer: Any) -> Text:stats_text.append("\n")- stats_text.append("Agents ", style="dim")- stats_text.append(str(agent_count), style="white")- stats_text.append(" · ", style="dim white")- stats_text.append("Tools ", style="dim")- stats_text.append(str(tool_count), style="white")-- llm_stats = tracer.get_total_llm_stats()- total_stats = llm_stats["total"]-- stats_text.append("\n")-- stats_text.append("Input Tokens ", style="dim")- stats_text.append(format_token_count(total_stats["input_tokens"]), style="white")-- stats_text.append(" · ", style="dim white")- stats_text.append("Cached Tokens ", style="dim")- stats_text.append(format_token_count(total_stats["cached_tokens"]), style="white")-- stats_text.append("\n")-- stats_text.append("Output Tokens ", style="dim")- stats_text.append(format_token_count(total_stats["output_tokens"]), style="white")-- stats_text.append(" · ", style="dim white")- stats_text.append("Cost ", style="dim")- stats_text.append(f"${total_stats['cost']:.4f}", style="#fbbf24")-return stats_text-def build_tui_stats_text(tracer: Any) -> Text:+def build_tui_stats_text(scan_store: Any) -> Text:stats_text = Text()- if not tracer:+ if not scan_store:return stats_textmodel = load_settings().llm.model or "unknown"stats_text.append(str(model), style="white")- llm_stats = tracer.get_total_llm_stats()- total_stats = llm_stats["total"]-- total_tokens = total_stats["input_tokens"] + total_stats["output_tokens"]- if total_tokens > 0:- stats_text.append("\n")- stats_text.append(f"{format_token_count(total_tokens)} tokens", style="white")-- if total_stats["cost"] > 0:- stats_text.append(" · ", style="white")- stats_text.append(f"${total_stats['cost']:.2f}", style="white")-- caido_url = getattr(tracer, "caido_url", None)+ caido_url = getattr(scan_store, "caido_url", None)if caido_url:stats_text.append("\n")stats_text.append("Caido: ", style="bold white")diff --git a/strix/orchestration/__init__.py b/strix/orchestration/__init__.pyindex bf6a9620..7dab3be7 100644--- a/strix/orchestration/__init__.py+++ b/strix/orchestration/__init__.py@@ -3,8 +3,7 @@- :class:`AgentCoordinator` owns Strix-specific graph/status/wake state.- SDK ``SQLiteSession`` owns per-agent conversation history and messagetransport.-- :func:`run_with_continuation` wraps SDK ``Runner.run_streamed`` only- enough to keep interactive agents addressable between bounded runs.+- ``runner.py`` owns SDK ``Runner.run_streamed`` and child-agent spawning.Import deeply (for example, ``from strix.orchestration.coordinatorimport AgentCoordinator``) so ``import strix.orchestration`` doesn'tdiff --git a/strix/orchestration/coordinator.py b/strix/orchestration/coordinator.pyindex a6f96cbd..9e1e3cc5 100644--- a/strix/orchestration/coordinator.py+++ b/strix/orchestration/coordinator.py@@ -13,39 +13,27 @@ import jsonimport loggingimport tempfilefrom dataclasses import dataclass, field-from datetime import UTC, datetimefrom pathlib import Path-from typing import TYPE_CHECKING, Any, Literal--from agents import Runner-from agents.exceptions import AgentsException, MaxTurnsExceeded, UserError-from agents.memory import SQLiteSession-from openai import APIError+from typing import TYPE_CHECKING, Any, Literal, castif TYPE_CHECKING:from agents.items import TResponseInputItemfrom agents.memory import Session- from agents.result import RunResultBase, RunResultStreaming- from agents.run_config import RunConfiglogger = logging.getLogger(__name__)-Status = Literal["running", "waiting", "completed", "stopped", "crashed", "failed", "llm_failed"]-ACTIVE_AGENT_STATUSES = {"running", "waiting", "llm_failed"}-_SNAPSHOT_VERSION = 3-_WAITING_TIMEOUT_SUBAGENT = 300.0-_TIMEOUT_RESUME_MESSAGE = "Waiting timeout reached. Resuming execution."+Status = Literal["running", "waiting", "completed", "stopped", "crashed", "failed"]@dataclass(slots=True)class AgentRuntime:session: Session | None = Nonetask: asyncio.Task[Any] | None = None- stream: RunResultStreaming | None = None+ stream: Any | None = None+ interrupt_on_message: bool = Falsewake: asyncio.Event = field(default_factory=asyncio.Event)- tool_calls: dict[str, str] = field(default_factory=dict)class AgentCoordinator:@@ -57,9 +45,6 @@ class AgentCoordinator:self.names: dict[str, str] = {}self.metadata: dict[str, dict[str, Any]] = {}self.pending_counts: dict[str, int] = {}- self.pending_user_counts: dict[str, int] = {}- self.queued_messages: dict[str, list[dict[str, Any]]] = {}- self.stats_live: dict[str, dict[str, Any]] = {}self.runtimes: dict[str, AgentRuntime] = {}self._lock = asyncio.Lock()self._snapshot_path: Path | None = None@@ -75,23 +60,15 @@ class AgentCoordinator:*,task: str | None = None,skills: list[str] | None = None,- is_whitebox: bool = False,- scan_mode: str = "deep",- diff_scope: dict[str, Any] | None = None,) -> None:async with self._lock:self.statuses[agent_id] = "running"self.parent_of[agent_id] = parent_idself.names[agent_id] = nameself.pending_counts.setdefault(agent_id, 0)- self.pending_user_counts.setdefault(agent_id, 0)- self.stats_live.setdefault(agent_id, _empty_stats())self.metadata[agent_id] = {"task": task or "","skills": list(skills or []),- "is_whitebox": bool(is_whitebox),- "scan_mode": scan_mode,- "diff_scope": diff_scope,}self.runtimes.setdefault(agent_id, AgentRuntime())logger.info("agent.register %s (%s) parent=%s", agent_id, name, parent_id or "-")@@ -103,6 +80,7 @@ class AgentCoordinator:*,session: Session | None = None,task: asyncio.Task[Any] | None = None,+ interrupt_on_message: bool | None = None,) -> None:async with self._lock:runtime = self.runtimes.setdefault(agent_id, AgentRuntime())@@ -110,8 +88,8 @@ class AgentCoordinator:runtime.session = sessionif task is not None:runtime.task = task- if session is not None:- await self.flush_queued_messages(agent_id)+ if interrupt_on_message is not None:+ runtime.interrupt_on_message = interrupt_on_messageasync def mark_running(self, agent_id: str) -> None:async with self._lock:@@ -122,9 +100,6 @@ class AgentCoordinator:async def park_waiting(self, agent_id: str) -> None:await self.set_status(agent_id, "waiting")- async def mark_llm_failed(self, agent_id: str) -> None:- await self.set_status(agent_id, "llm_failed")-async def set_status(self, agent_id: str, status: Status | str) -> None:async with self._lock:if agent_id not in self.statuses:@@ -137,17 +112,15 @@ class AgentCoordinator:async def send(self, target_agent_id: str, message: dict[str, Any]) -> bool:"""Deliver a user/peer message by appending it to the target SDK session."""- should_queue = Falseasync with self._lock:if target_agent_id not in self.statuses:logger.debug("agent.send dropped unknown target=%s", target_agent_id)return Falseruntime = self.runtimes.setdefault(target_agent_id, AgentRuntime())session = runtime.session- should_queue = session is None or runtime.stream is not None- if should_queue:- self.queued_messages.setdefault(target_agent_id, []).append(dict(message))- if session is not None and not should_queue:+ stream = runtime.stream+ interrupt = runtime.interrupt_on_message+ if session is not None:try:await session.add_items([self._message_to_session_item(message)])except Exception:@@ -158,81 +131,55 @@ class AgentCoordinator:return Falseasync with self._lock:self.pending_counts[target_agent_id] = self.pending_counts.get(target_agent_id, 0) + 1- if message.get("from") == "user":- self.pending_user_counts[target_agent_id] = (- self.pending_user_counts.get(target_agent_id, 0) + 1- )self.runtimes.setdefault(target_agent_id, AgentRuntime()).wake.set()- if should_queue:- logger.debug(- "agent.send %s queued until SDK session is safe to append", target_agent_id- )+ if stream is not None and interrupt:+ stream.cancel(mode="immediate")await self._maybe_snapshot()return True- async def flush_queued_messages(self, agent_id: str) -> None:- async with self._lock:- runtime = self.runtimes.setdefault(agent_id, AgentRuntime())- session = runtime.session- queued = self.queued_messages.pop(agent_id, [])- if not queued:- return- if session is None:- async with self._lock:- self.queued_messages.setdefault(agent_id, []).extend(queued)- return- try:- await session.add_items([self._message_to_session_item(msg) for msg in queued])- except Exception:- async with self._lock:- self.queued_messages.setdefault(agent_id, [])[0:0] = queued- logger.exception("agent.flush_queued_messages failed for %s", agent_id)-- async def wait_for_message(self, agent_id: str, *, user_only: bool = False) -> None:+ async def wait_for_message(self, agent_id: str) -> None:while True:async with self._lock:- pending = (- self.pending_user_counts.get(agent_id, 0)- if user_only- else self.pending_counts.get(agent_id, 0)- )- if pending > 0:+ if self.pending_counts.get(agent_id, 0) > 0:returnwake = self.runtimes.setdefault(agent_id, AgentRuntime()).wakewake.clear()await wake.wait()- async def wait_for_user_message(self, agent_id: str) -> None:- await self.wait_for_message(agent_id, user_only=True)-- async def consume_wake(self, agent_id: str) -> None:+ async def consume_pending(+ self,+ agent_id: str,+ *,+ include_items: bool = False,+ ) -> tuple[int, list[Any]]:async with self._lock:+ count = self.pending_counts.get(agent_id, 0)self.pending_counts[agent_id] = 0- self.pending_user_counts[agent_id] = 0-- async def pending_count(self, agent_id: str) -> int:- async with self._lock:- return self.pending_counts.get(agent_id, 0)-- async def recent_session_items(self, agent_id: str, count: int) -> list[TResponseInputItem]:- if count <= 0:- return []- async with self._lock:session = self.runtimes.get(agent_id, AgentRuntime()).session- if session is None:- return []+ if count <= 0:+ return 0, []+ if not include_items or session is None:+ return count, []items = await session.get_items()- return list(items[-count:])+ return count, list(items[-count:])- async def request_interrupt(self, agent_id: str, mode: str = "after_turn") -> bool:+ async def session_items_snapshot(self) -> dict[str, list[Any]]:async with self._lock:- stream = self.runtimes.get(agent_id, AgentRuntime()).stream- if stream is None:- return False- stream.cancel(mode=mode) # type: ignore[arg-type]- return True+ sessions = {+ aid: runtime.session+ for aid, runtime in self.runtimes.items()+ if runtime.session is not None+ }- async def request_stop(self, agent_id: str, *, interrupt: bool = True) -> None:+ snapshots: dict[str, list[Any]] = {}+ for aid, session in sessions.items():+ try:+ snapshots[aid] = list(await session.get_items())+ except Exception:+ logger.exception("failed to read SDK session items for %s", aid)+ return snapshots++ async def request_stop(self, agent_id: str) -> None:async with self._lock:if agent_id not in self.statuses:return@@ -240,7 +187,7 @@ class AgentCoordinator:runtime = self.runtimes.setdefault(agent_id, AgentRuntime())runtime.wake.set()stream = runtime.stream- if interrupt and stream is not None:+ if stream is not None:stream.cancel(mode="after_turn")await self._maybe_snapshot()@@ -266,7 +213,7 @@ class AgentCoordinator:async def attach_stream(self,agent_id: str,- stream: RunResultStreaming,+ stream: Any,) -> None:async with self._lock:self.runtimes.setdefault(agent_id, AgentRuntime()).stream = stream@@ -274,7 +221,7 @@ class AgentCoordinator:async def detach_stream(self,agent_id: str,- stream: RunResultStreaming,+ stream: Any,) -> None:async with self._lock:runtime = self.runtimes.setdefault(agent_id, AgentRuntime())@@ -284,49 +231,40 @@ class AgentCoordinator:async def active_agents_except(self, agent_id: str) -> list[dict[str, Any]]:async with self._lock:return [- self._agent_info_locked(aid)+ {+ "agent_id": aid,+ "name": self.names.get(aid, aid),+ "status": status,+ "parent_id": self.parent_of.get(aid),+ }for aid, status in self.statuses.items()- if aid != agent_id and status in ACTIVE_AGENT_STATUSES+ if aid != agent_id and status in {"running", "waiting"}]- async def agent_info(self, agent_id: str) -> dict[str, Any] | None:- async with self._lock:- if agent_id not in self.statuses:- return None- return self._agent_info_locked(agent_id)-async def graph_snapshot(self,) -> tuple[dict[str, str | None], dict[str, Status], dict[str, str]]:async with self._lock:return dict(self.parent_of), dict(self.statuses), dict(self.names)- async def record_usage(self, agent_id: str, usage: Any) -> None:- if usage is None:- return- async with self._lock:- stats = self.stats_live.setdefault(agent_id, _empty_stats())- stats["calls"] += 1- stats["in"] += getattr(usage, "input_tokens", 0) or 0- stats["out"] += getattr(usage, "output_tokens", 0) or 0- details = getattr(usage, "input_tokens_details", None)- stats["cached"] += getattr(details, "cached_tokens", 0) or 0 if details else 0-def _message_to_session_item(self, message: dict[str, Any]) -> TResponseInputItem:sender = str(message.get("from", "unknown"))content = str(message.get("content", ""))if sender == "user":- return {"role": "user", "content": content}+ return cast("TResponseInputItem", {"role": "user", "content": content})sender_name = self.names.get(sender, sender)msg_type = message.get("type", "information")priority = message.get("priority", "normal")- return {- "role": "user",- "content": (- f"[Message from {sender_name} ({sender}) | type={msg_type} "- f"| priority={priority}]\n{content}"- ),- }+ return cast(+ "TResponseInputItem",+ {+ "role": "user",+ "content": (+ f"[Message from {sender_name} ({sender}) | type={msg_type} "+ f"| priority={priority}]\n{content}"+ ),+ },+ )def _subtree_order_locked(self, agent_id: str) -> list[str]:queue = [agent_id]@@ -337,29 +275,14 @@ class AgentCoordinator:queue.extend(child for child, parent in self.parent_of.items() if parent == aid)return order- def _agent_info_locked(self, agent_id: str) -> dict[str, Any]:- return {- "agent_id": agent_id,- "name": self.names.get(agent_id, agent_id),- "status": self.statuses.get(agent_id),- "parent_id": self.parent_of.get(agent_id),- "pending_messages": self.pending_counts.get(agent_id, 0),- }-async def snapshot(self) -> dict[str, Any]:async with self._lock:return {- "version": _SNAPSHOT_VERSION,"statuses": dict(self.statuses),"parent_of": dict(self.parent_of),"names": dict(self.names),"metadata": {aid: dict(md) for aid, md in self.metadata.items()},"pending_counts": dict(self.pending_counts),- "pending_user_counts": dict(self.pending_user_counts),- "queued_messages": {- aid: [dict(msg) for msg in msgs] for aid, msgs in self.queued_messages.items()- },- "stats_live": {aid: dict(s) for aid, s in self.stats_live.items()},}async def restore(self, snap: dict[str, Any]) -> None:@@ -369,12 +292,6 @@ class AgentCoordinator:self.names = dict(snap.get("names", {}))self.metadata = {aid: dict(md) for aid, md in snap.get("metadata", {}).items()}self.pending_counts = dict(snap.get("pending_counts", {}))- self.pending_user_counts = dict(snap.get("pending_user_counts", {}))- self.queued_messages = {- aid: [dict(msg) for msg in msgs]- for aid, msgs in snap.get("queued_messages", {}).items()- }- self.stats_live = {aid: dict(s) for aid, s in snap.get("stats_live", {}).items()}for aid in self.statuses:self.runtimes.setdefault(aid, AgentRuntime())@@ -404,297 +321,3 @@ class AgentCoordinator:def coordinator_from_context(ctx: dict[str, Any]) -> AgentCoordinator | None:coordinator = ctx.get("coordinator")return coordinator if isinstance(coordinator, AgentCoordinator) else None---async def run_with_continuation(- *,- agent: Any,- initial_input: Any,- run_config: RunConfig,- context: dict[str, Any],- max_turns: int,- coordinator: AgentCoordinator,- agent_id: str,- interactive: bool,- session: Session | None = None,- start_parked: bool = False,-) -> RunResultBase | None:- await coordinator.attach_runtime(agent_id, session=session)- waiting_timeout = await _waiting_timeout(coordinator, agent_id, interactive)- result: RunResultBase | None = None-- if not (start_parked and interactive):- result = await _run_cycle(- agent,- coordinator,- agent_id,- input_data=initial_input,- run_config=run_config,- context=context,- max_turns=max_turns,- session=session,- interactive=interactive,- )-- if not interactive:- return result-- while True:- async with coordinator._lock:- status = coordinator.statuses.get(agent_id)-- try:- if status == "llm_failed":- await coordinator.wait_for_user_message(agent_id)- elif waiting_timeout is None:- await coordinator.wait_for_message(agent_id)- else:- await asyncio.wait_for(- coordinator.wait_for_message(agent_id),- timeout=waiting_timeout,- )- except asyncio.CancelledError:- return result- except TimeoutError:- result = await _run_cycle(- agent,- coordinator,- agent_id,- input_data=_TIMEOUT_RESUME_MESSAGE,- run_config=run_config,- context=context,- max_turns=max_turns,- session=session,- interactive=interactive,- )- continue-- await coordinator.consume_wake(agent_id)- result = await _run_cycle(- agent,- coordinator,- agent_id,- input_data=[],- run_config=run_config,- context=context,- max_turns=max_turns,- session=session,- interactive=interactive,- )---async def _waiting_timeout(- coordinator: AgentCoordinator,- agent_id: str,- interactive: bool,-) -> float | None:- if not interactive:- return None- async with coordinator._lock:- return (- _WAITING_TIMEOUT_SUBAGENT if coordinator.parent_of.get(agent_id) is not None else None- )---async def _run_cycle(- agent: Any,- coordinator: AgentCoordinator,- agent_id: str,- *,- input_data: Any,- run_config: RunConfig,- context: dict[str, Any],- max_turns: int,- session: Session | None,- interactive: bool,-) -> RunResultBase | None:- try:- await coordinator.mark_running(agent_id)- stream = Runner.run_streamed(- agent,- input=input_data,- run_config=run_config,- context=context,- max_turns=max_turns,- session=session,- )- await coordinator.attach_stream(agent_id, stream)- try:- async for event in stream.stream_events():- await _handle_stream_event(coordinator, agent_id, context, event)- finally:- await coordinator.detach_stream(agent_id, stream)- await coordinator.flush_queued_messages(agent_id)- await _settle_run_result(coordinator, agent_id, stream.final_output, interactive, context)- return stream- except (AgentsException, APIError):- if not interactive:- raise- logger.exception("LLM/runtime failure for %s; waiting for user resume", agent_id)- await coordinator.mark_llm_failed(agent_id)- return None- except Exception as exc:- if not interactive:- raise- status: Status = "stopped" if isinstance(exc, MaxTurnsExceeded) else "crashed"- if isinstance(exc, UserError):- status = "failed"- logger.exception("agent run failed for %s; parking as %s", agent_id, status)- await coordinator.set_status(agent_id, status)- await _notify_parent_on_crash(coordinator, agent_id, status)- _mirror_tracer_status(context, coordinator, agent_id, status)- return None---async def _settle_run_result(- coordinator: AgentCoordinator,- agent_id: str,- final_output: Any,- interactive: bool,- context: dict[str, Any],-) -> None:- parsed = _parse_final_output(final_output)- async with coordinator._lock:- current_status = coordinator.statuses.get(agent_id)-- if current_status == "stopped":- status: Status = "stopped"- elif parsed.get("agent_completed") or parsed.get("scan_completed"):- status = "completed"- elif parsed.get("agent_waiting") or interactive:- status = "waiting"- else:- status = "crashed"-- await coordinator.set_status(agent_id, status)- await _notify_parent_on_crash(coordinator, agent_id, status)- _mirror_tracer_status(context, coordinator, agent_id, status)---def _parse_final_output(output: Any) -> dict[str, Any]:- if not isinstance(output, str):- return {}- try:- parsed = json.loads(output)- except (TypeError, ValueError):- return {}- return parsed if isinstance(parsed, dict) and parsed.get("success") else {}---async def _notify_parent_on_crash(- coordinator: AgentCoordinator,- agent_id: str,- status: str,-) -> None:- if status != "crashed":- return- async with coordinator._lock:- parent = coordinator.parent_of.get(agent_id)- name = coordinator.names.get(agent_id, agent_id)- if parent is None:- return- await coordinator.send(- parent,- {- "from": agent_id,- "type": "crash",- "priority": "high",- "content": (- f"[Agent crash] {name} ({agent_id}) terminated unexpectedly. "- "Stop waiting on this child unless you want to message it again."- ),- },- )---def _mirror_tracer_status(- context: dict[str, Any],- coordinator: AgentCoordinator,- agent_id: str,- status: str,-) -> None:- tracer = context.get("tracer")- if tracer is None:- return- now = datetime.now(UTC).isoformat()- tracer.agents.setdefault(- agent_id,- {- "id": agent_id,- "name": coordinator.names.get(agent_id, agent_id),- "parent_id": coordinator.parent_of.get(agent_id),- "created_at": now,- },- )- tracer.agents[agent_id]["status"] = status- tracer.agents[agent_id]["updated_at"] = now---async def _handle_stream_event(- coordinator: AgentCoordinator,- agent_id: str,- context: dict[str, Any],- event: Any,-) -> None:- tracer = context.get("tracer")- if event.type == "raw_response_event":- response = getattr(event.data, "response", None)- usage = getattr(response, "usage", None)- if usage is not None:- await coordinator.record_usage(agent_id, usage)- if usage is not None and tracer is not None and hasattr(tracer, "record_llm_usage"):- details = getattr(usage, "input_tokens_details", None)- tracer.record_llm_usage(- input_tokens=int(getattr(usage, "input_tokens", 0) or 0),- output_tokens=int(getattr(usage, "output_tokens", 0) or 0),- cached_tokens=int(getattr(details, "cached_tokens", 0) or 0) if details else 0,- )- return- if tracer is None or event.type != "run_item_stream_event":- return- item = event.item- raw = getattr(item, "raw_item", None)- if event.name == "tool_called":- call_id = str(getattr(raw, "call_id", None) or getattr(raw, "id", ""))- tool_name = str(getattr(raw, "name", None) or getattr(raw, "type", "tool"))- args = _parse_tool_args(getattr(raw, "arguments", None))- runtime = coordinator.runtimes.setdefault(agent_id, AgentRuntime())- if call_id:- runtime.tool_calls[call_id] = tool_name- tracer.log_tool_start(agent_id, tool_name, args)- elif event.name == "tool_output":- call_id = str(getattr(raw, "call_id", None) or "")- runtime = coordinator.runtimes.setdefault(agent_id, AgentRuntime())- tool_name = runtime.tool_calls.get(call_id, "tool")- tracer.log_tool_end(agent_id, tool_name, _dump_raw(raw))---def _parse_tool_args(raw: Any) -> dict[str, Any]:- if not raw:- return {}- try:- parsed = json.loads(raw)- except (TypeError, ValueError):- return {}- return parsed if isinstance(parsed, dict) else {}---def _dump_raw(raw: Any) -> Any:- if hasattr(raw, "model_dump"):- return raw.model_dump(exclude_unset=True)- return raw---def open_agent_session(agent_id: str, path: Path) -> SQLiteSession:- path.parent.mkdir(parents=True, exist_ok=True)- return SQLiteSession(session_id=agent_id, db_path=path)---def _empty_stats() -> dict[str, Any]:- return {- "in": 0,- "out": 0,- "cached": 0,- "cost": 0.0,- "calls": 0,- }diff --git a/strix/orchestration/runner.py b/strix/orchestration/runner.pynew file mode 100644index 00000000..ee6a5073--- /dev/null+++ b/strix/orchestration/runner.py@@ -0,0 +1,636 @@+"""Top-level Strix scan runner.++The SDK owns model/tool execution and per-agent sessions. This module owns+Strix-specific scan setup, child-agent startup, resume, and the small wake loop+needed to keep every agent addressable after its SDK run parks.+"""++from __future__ import annotations++import asyncio+import contextlib+import json+import logging+import uuid+from pathlib import Path+from typing import TYPE_CHECKING, Any++from agents import RunConfig, Runner+from agents.exceptions import AgentsException, MaxTurnsExceeded, UserError+from agents.memory import SQLiteSession+from agents.sandbox import SandboxRunConfig+from openai import APIError++from strix.agents.factory import build_strix_agent, make_child_factory+from strix.config import load_settings+from strix.llm.multi_provider_setup import build_multi_provider+from strix.orchestration.coordinator import AgentCoordinator, Status+from strix.orchestration.utils import (+ DEFAULT_MAX_TURNS,+ build_root_task,+ build_scope_context,+ child_initial_input,+ make_model_settings,+)+from strix.runtime import session_manager+from strix.telemetry.logging import set_scan_id, setup_scan_logging+++if TYPE_CHECKING:+ from agents.memory import Session+ from agents.result import RunResultBase+++logger = logging.getLogger(__name__)+++def _open_agent_session(agent_id: str, path: Path) -> SQLiteSession:+ path.parent.mkdir(parents=True, exist_ok=True)+ return SQLiteSession(session_id=agent_id, db_path=path)+++async def _run_agent_loop(+ *,+ agent: Any,+ initial_input: Any,+ run_config: RunConfig,+ context: dict[str, Any],+ max_turns: int,+ coordinator: AgentCoordinator,+ agent_id: str,+ interactive: bool,+ session: Session | None = None,+ start_parked: bool = False,+) -> RunResultBase | None:+ await coordinator.attach_runtime(+ agent_id,+ session=session,+ interrupt_on_message=interactive,+ )+ result: RunResultBase | None = None++ if not (start_parked and interactive):+ result = await _run_cycle(+ agent,+ coordinator,+ agent_id,+ input_data=initial_input,+ run_config=run_config,+ context=context,+ max_turns=max_turns,+ session=session,+ interactive=interactive,+ )++ if not interactive:+ return result++ while True:+ try:+ await coordinator.wait_for_message(agent_id)+ except asyncio.CancelledError:+ return result++ await coordinator.consume_pending(agent_id)+ result = await _run_cycle(+ agent,+ coordinator,+ agent_id,+ input_data=[],+ run_config=run_config,+ context=context,+ max_turns=max_turns,+ session=session,+ interactive=interactive,+ )+++async def _run_cycle(+ agent: Any,+ coordinator: AgentCoordinator,+ agent_id: str,+ *,+ input_data: Any,+ run_config: RunConfig,+ context: dict[str, Any],+ max_turns: int,+ session: Session | None,+ interactive: bool,+) -> RunResultBase | None:+ try:+ await coordinator.mark_running(agent_id)+ stream = Runner.run_streamed(+ agent,+ input=input_data,+ run_config=run_config,+ context=context,+ max_turns=max_turns,+ session=session,+ )+ await coordinator.attach_stream(agent_id, stream)+ try:+ async for _event in stream.stream_events():+ pass+ if stream.run_loop_exception is not None:+ raise stream.run_loop_exception+ finally:+ await coordinator.detach_stream(agent_id, stream)+ except Exception as exc:+ if not interactive:+ raise+ if isinstance(exc, MaxTurnsExceeded):+ status: Status = "stopped"+ elif isinstance(exc, UserError | AgentsException | APIError):+ status = "failed"+ else:+ status = "crashed"+ logger.exception("agent run failed for %s; parking as %s", agent_id, status)+ await coordinator.set_status(agent_id, status)+ await _notify_parent_on_crash(coordinator, agent_id, status)+ return None+ else:+ await _settle_run_result(coordinator, agent_id, interactive)+ return stream+++async def _settle_run_result(+ coordinator: AgentCoordinator,+ agent_id: str,+ interactive: bool,+) -> None:+ async with coordinator._lock:+ current_status = coordinator.statuses.get(agent_id)++ if current_status != "running":+ return++ status: Status = "waiting" if interactive else "crashed"+ await coordinator.set_status(agent_id, status)+ await _notify_parent_on_crash(coordinator, agent_id, status)+++async def _notify_parent_on_crash(+ coordinator: AgentCoordinator,+ agent_id: str,+ status: str,+) -> None:+ if status != "crashed":+ return+ async with coordinator._lock:+ parent = coordinator.parent_of.get(agent_id)+ name = coordinator.names.get(agent_id, agent_id)+ if parent is None:+ return+ await coordinator.send(+ parent,+ {+ "from": agent_id,+ "type": "crash",+ "priority": "high",+ "content": (+ f"[Agent crash] {name} ({agent_id}) terminated unexpectedly. "+ "Stop waiting on this child unless you want to message it again."+ ),+ },+ )+++async def _spawn_child_agent(+ *,+ coordinator: AgentCoordinator,+ factory: Any,+ agents_db_path: Path,+ sessions_to_close: list[SQLiteSession],+ run_config: RunConfig,+ max_turns: int,+ interactive: bool,+ parent_ctx: dict[str, Any],+ name: str,+ task: str,+ skills: list[str],+ parent_history: list[Any],+) -> dict[str, Any]:+ parent_id = parent_ctx.get("agent_id")+ if not isinstance(parent_id, str):+ raise TypeError("Parent agent_id missing from context")++ child_id = uuid.uuid4().hex[:8]+ child_agent = factory(name=name, skills=skills)+ await coordinator.register(+ child_id,+ name,+ parent_id,+ task=task,+ skills=skills,+ )++ await _start_child_runner(+ parent_ctx=parent_ctx,+ coordinator=coordinator,+ agents_db_path=agents_db_path,+ sessions_to_close=sessions_to_close,+ run_config=run_config,+ max_turns=max_turns,+ interactive=interactive,+ child_agent=child_agent,+ child_id=child_id,+ name=name,+ parent_id=parent_id,+ task=task,+ initial_input=child_initial_input(+ name=name,+ child_id=child_id,+ parent_id=parent_id,+ task=task,+ parent_history=parent_history,+ ),+ )++ return {+ "success": True,+ "agent_id": child_id,+ "name": name,+ "parent_id": parent_id,+ "message": f"Spawned '{name}' ({child_id}) running in parallel.",+ }+++async def _start_child_runner(+ *,+ parent_ctx: dict[str, Any],+ coordinator: AgentCoordinator,+ agents_db_path: Path,+ sessions_to_close: list[SQLiteSession],+ run_config: RunConfig,+ max_turns: int,+ interactive: bool,+ child_agent: Any,+ child_id: str,+ name: str,+ parent_id: str | None,+ task: str,+ initial_input: Any,+ start_parked: bool = False,+) -> None:+ session = _open_agent_session(child_id, agents_db_path)+ sessions_to_close.append(session)+ await coordinator.attach_runtime(child_id, session=session)++ child_ctx: dict[str, Any] = dict(parent_ctx)+ child_ctx["agent_id"] = child_id+ child_ctx["parent_id"] = parent_id+ child_ctx["task"] = task++ task_handle = asyncio.create_task(+ _run_agent_loop(+ agent=child_agent,+ initial_input=initial_input,+ run_config=run_config,+ context=child_ctx,+ max_turns=max_turns,+ coordinator=coordinator,+ agent_id=child_id,+ interactive=interactive,+ session=session,+ start_parked=start_parked,+ ),+ name=f"agent-{name}-{child_id}",+ )+ await coordinator.attach_runtime(child_id, task=task_handle)+++async def run_strix_scan(+ *,+ scan_config: dict[str, Any],+ scan_id: str | None = None,+ image: str,+ local_sources: list[dict[str, str]] | None = None,+ coordinator: AgentCoordinator | None = None,+ interactive: bool = False,+ max_turns: int = DEFAULT_MAX_TURNS,+ model: str | None = None,+ cleanup_on_exit: bool = True,+) -> RunResultBase | None:+ """Run or resume one Strix scan against a sandbox."""+ if scan_id is None:+ scan_id = f"scan-{uuid.uuid4().hex[:8]}"++ # Resolve run_dir before any heavy bring-up so the log file captures+ # everything from sandbox start onwards.+ run_dir = Path.cwd() / "strix_runs" / scan_id+ run_dir.mkdir(parents=True, exist_ok=True)+ teardown_logging = setup_scan_logging(run_dir)+ set_scan_id(scan_id)++ agents_path = run_dir / "agents.json"+ agents_db = run_dir / "agents.db"+ is_resume = agents_path.exists()++ logger.info(+ "%s Strix scan %s (image=%s, max_turns=%d, interactive=%s, run_dir=%s)",+ "Resuming" if is_resume else "Starting",+ scan_id,+ image,+ max_turns,+ interactive,+ run_dir,+ )++ settings = load_settings()+ resolved_model = model or settings.llm.model+ if not resolved_model:+ raise RuntimeError(+ "No LLM model configured. Set STRIX_LLM env or pass model= to run_strix_scan().",+ )+ logger.info("LLM model resolved: %s", resolved_model)++ # Caller may pre-create the coordinator so it can route stop/chat+ # commands while the scan loop runs in another thread.+ if coordinator is None:+ coordinator = AgentCoordinator()+ coordinator.set_snapshot_path(agents_path)++ # Wire the per-agent todo store to ``{run_dir}/todos.json`` (mirrored+ # on every CRUD) and reload any prior todos so respawned subagents+ # find their lists intact. Same for the shared notes store.+ from strix.tools.notes.tools import hydrate_notes_from_disk+ from strix.tools.todo.tools import hydrate_todos_from_disk++ hydrate_todos_from_disk(run_dir)+ hydrate_notes_from_disk(run_dir)++ root_id: str | None = None+ if is_resume:+ try:+ snap = json.loads(agents_path.read_text(encoding="utf-8"))+ except (OSError, json.JSONDecodeError) as exc:+ raise RuntimeError(+ f"Cannot resume scan {scan_id}: agents.json is unreadable: {exc}",+ ) from exc+ if not agents_db.exists():+ raise RuntimeError(+ f"Cannot resume scan {scan_id}: missing SDK session database at {agents_db}",+ )+ await coordinator.restore(snap)+ for aid, parent in coordinator.parent_of.items():+ if parent is None:+ root_id = aid+ break+ if root_id is None:+ raise RuntimeError(+ f"Cannot resume scan {scan_id}: agents.json has no root agent (parent=None)",+ )+ logger.info(+ "Resume: restored coordinator with %d agent(s); root=%s",+ len(coordinator.statuses),+ root_id,+ )+ else:+ root_id = uuid.uuid4().hex[:8]++ logger.info("Bringing up sandbox session for scan %s", scan_id)+ bundle = await session_manager.create_or_reuse(+ scan_id,+ image=image,+ local_sources=local_sources or [],+ )+ logger.info("Sandbox ready for scan %s", scan_id)++ sessions_to_close: list[SQLiteSession] = []++ try:+ targets = scan_config.get("targets") or []+ scan_mode = str(scan_config.get("scan_mode") or "deep")+ is_whitebox = any(t.get("type") == "local_code" for t in targets)+ skills = list(scan_config.get("skills") or [])+ root_task = build_root_task(scan_config)+ model_settings = make_model_settings(settings.llm.reasoning_effort)+ run_config = RunConfig(+ model=resolved_model,+ model_provider=build_multi_provider(),+ model_settings=model_settings,+ sandbox=SandboxRunConfig(client=bundle["client"], session=bundle["session"]),+ trace_include_sensitive_data=False,+ )++ scope_context = build_scope_context(scan_config)++ root_agent = build_strix_agent(+ name="strix",+ skills=skills,+ is_root=True,+ scan_mode=scan_mode,+ is_whitebox=is_whitebox,+ interactive=interactive,+ system_prompt_context=scope_context,+ )++ if not is_resume:+ await coordinator.register(+ root_id,+ "strix",+ parent_id=None,+ task=root_task,+ skills=skills,+ )++ agent_factory = make_child_factory(+ scan_mode=scan_mode,+ is_whitebox=is_whitebox,+ interactive=interactive,+ system_prompt_context=scope_context,+ )++ async def spawn_child_agent(**kwargs: Any) -> dict[str, Any]:+ return await _spawn_child_agent(+ coordinator=coordinator,+ factory=agent_factory,+ agents_db_path=agents_db,+ sessions_to_close=sessions_to_close,+ run_config=run_config,+ max_turns=max_turns,+ interactive=interactive,+ **kwargs,+ )++ context: dict[str, Any] = {+ "coordinator": coordinator,+ "sandbox_session": bundle["session"],+ "caido_client": bundle["caido_client"],+ "agent_id": root_id,+ "parent_id": None,+ "interactive": interactive,+ "spawn_child_agent": spawn_child_agent,+ }++ # All agents share one SQLite database; SDK session_id separates+ # each agent's conversation inside that database.+ root_session = _open_agent_session(root_id, agents_db)+ sessions_to_close.append(root_session)+ await coordinator.attach_runtime(root_id, session=root_session)++ if is_resume:+ await _respawn_subagents(+ coordinator=coordinator,+ factory=agent_factory,+ agents_db_path=agents_db,+ sessions_to_close=sessions_to_close,+ run_config=run_config,+ max_turns=max_turns,+ interactive=interactive,+ parent_ctx=context,+ root_id=root_id,+ )++ initial_input: Any = [] if is_resume else root_task++ # Resume + new ``--instruction``: SDK replay drives root from+ # agents.db with ``initial_input=[]``, so a brand-new instruction+ # passed on the resume CLI would otherwise be silently ignored.+ # Inject it as a fresh user message in root's SDK session; the+ # next run cycle will replay it with the rest of the session.+ resume_instruction = str(scan_config.get("resume_instruction") or "").strip()+ if is_resume and resume_instruction:+ await coordinator.send(+ root_id,+ {+ "from": "user",+ "type": "instruction",+ "priority": "high",+ "content": resume_instruction,+ },+ )+ logger.info(+ "Resume: injected new instruction into root SDK session (len=%d)",+ len(resume_instruction),+ )++ async with coordinator._lock:+ root_status = coordinator.statuses.get(root_id)++ return await _run_agent_loop(+ agent=root_agent,+ initial_input=initial_input,+ run_config=run_config,+ context=context,+ max_turns=max_turns,+ coordinator=coordinator,+ agent_id=root_id,+ interactive=interactive,+ session=root_session,+ start_parked=bool(interactive and is_resume and root_status != "running"),+ )+ except BaseException:+ logger.exception("Strix scan %s failed", scan_id)+ # Cancel any descendant tasks the root spawned before unwinding.+ # cancel_descendants is idempotent and handles the empty-tree case.+ if root_id is not None:+ await coordinator.cancel_descendants(root_id)+ # The SDK's on_agent_end hook only fires after a successful+ # ``Runner.run_streamed`` reaches the agent's first turn. A+ # failure earlier (e.g., model-provider routing, sandbox+ # bring-up) leaves the root stuck at status="running" — the+ # TUI keeps animating "Initializing" forever. Finalize it+ # here so the coordinator reflects reality.+ with contextlib.suppress(Exception):+ await coordinator.set_status(root_id, "failed")+ raise+ finally:+ for s in sessions_to_close:+ with contextlib.suppress(Exception):+ s.close()+ with contextlib.suppress(Exception):+ await coordinator._maybe_snapshot()+ if cleanup_on_exit:+ logger.info("Tearing down sandbox session for scan %s", scan_id)+ await session_manager.cleanup(scan_id)+ logger.info("Strix scan %s done", scan_id)+ teardown_logging()+++async def _respawn_subagents(+ *,+ coordinator: AgentCoordinator,+ factory: Any,+ agents_db_path: Path,+ sessions_to_close: list[SQLiteSession],+ run_config: RunConfig,+ max_turns: int,+ interactive: bool,+ parent_ctx: dict[str, Any],+ root_id: str,+) -> None:+ """Re-spawn subagent runners from a restored coordinator snapshot.++ Each child gets its own SDK ``session_id`` inside the shared+ ``agents.db`` so the SDK replays its prior conversation. Interactive+ mode respawns every registered child as a parked runner unless it was+ actively running before the crash. That keeps completed/stopped/+ crashed/failed agents addressable: a later message wakes the SDK+ session instead of being dropped into a dead inbox.+ """+ async with coordinator._lock:+ # Snapshot the iteration view first so we can mutate via coordinator+ # below without "dict changed during iteration" trouble.+ agents_snapshot = [+ (aid, status, dict(coordinator.metadata.get(aid, {})))+ for aid, status in coordinator.statuses.items()+ ]+ candidates: list[tuple[str, str, str | None, dict[str, Any]]] = []+ for aid, status, md in agents_snapshot:+ if not interactive and status not in {"running", "waiting"}:+ continue+ if coordinator.parent_of.get(aid) is None or aid == root_id:+ continue+ md["_restored_status"] = status+ candidates.append(+ (+ aid,+ coordinator.names.get(aid, aid),+ coordinator.parent_of.get(aid),+ md,+ )+ )++ for child_id, name, parent_id, md in candidates:+ try:+ restored_status = str(md.get("_restored_status") or "running")+ start_parked = interactive and restored_status != "running"++ if start_parked:+ logger.warning(+ "respawn %s (%s): starting parked from status=%s",+ child_id,+ name,+ restored_status,+ )++ child_skills = list(md.get("skills") or [])+ child_agent = factory(name=name, skills=child_skills)+ await _start_child_runner(+ parent_ctx=parent_ctx,+ coordinator=coordinator,+ agents_db_path=agents_db_path,+ sessions_to_close=sessions_to_close,+ run_config=run_config,+ max_turns=max_turns,+ interactive=interactive,+ child_agent=child_agent,+ child_id=child_id,+ name=name,+ parent_id=parent_id,+ task=str(md.get("task", "")),+ initial_input=[],+ start_parked=start_parked,+ )+ logger.info(+ "respawned %s (%s) parent=%s task_len=%d",+ child_id,+ name,+ parent_id or "-",+ len(md.get("task", "")),+ )+ except Exception:+ logger.exception("respawn %s failed; marking crashed", child_id)+ with contextlib.suppress(Exception):+ await coordinator.set_status(child_id, "crashed")diff --git a/strix/orchestration/scan.py b/strix/orchestration/scan.pydeleted file mode 100644index d8d97559..00000000--- a/strix/orchestration/scan.py+++ /dev/null@@ -1,645 +0,0 @@-"""Top-level scan entry point with auto-resume.--1. Build (or take from caller) the per-scan ``AgentCoordinator``.-2. Wire a snapshot path so lifecycle events auto-persist ``agents.json``.-3. Acquire an advisory file lock so a second ``strix`` process can't run- on the same ``scan_id`` concurrently.-4. **Resume detection**: if ``{run_dir}/agents.json`` already exists, restore- the coordinator, hydrate the tracer, reuse the persisted ``root_id`` instead- of generating a fresh one, and respawn every non-terminal subagent- from the shared SDK ``agents.db`` before starting the root.-5. Bring up (or reuse) a sandbox session for ``scan_id``.-6. Build the root ``Agent`` + child factory.-7. Open root ``SQLiteSession`` in ``agents.db`` so the SDK replays prior- turns on resume.-8. Call ``Runner.run`` (via ``run_with_continuation``).-9. ``finally``: close every per-agent session, take a final snapshot,- tear down the sandbox, release the lock.--Resume is **always on**: there is no flag — presence of ``agents.json`` is-the trigger. Fresh runs simply have no ``agents.json`` to begin with.-"""--from __future__ import annotations--import asyncio-import contextlib-import json-import logging-import uuid-from datetime import UTC, datetime-from pathlib import Path-from typing import TYPE_CHECKING, Any, Literal--from agents import RunConfig-from agents.memory import SQLiteSession-from agents.model_settings import ModelSettings-from agents.sandbox import SandboxRunConfig-from openai.types.shared import Reasoning--from strix.agents.factory import build_strix_agent, make_child_factory-from strix.config import load_settings-from strix.llm.multi_provider_setup import build_multi_provider-from strix.llm.retry import DEFAULT_RETRY-from strix.orchestration.coordinator import (- AgentCoordinator,- open_agent_session,- run_with_continuation,-)-from strix.runtime import session_manager-from strix.telemetry.logging import set_agent_id, set_scan_id, setup_scan_logging---#: Default ``max_turns`` budget passed to ``Runner.run``.-_MAX_TURNS = 300---if TYPE_CHECKING:- from agents.result import RunResultBase---logger = logging.getLogger(__name__)---def _build_root_task(scan_config: dict[str, Any]) -> str:- """Format the user-facing task for the root agent.-- Collects each target type into a labelled section, appends- diff-scope context if active, and tacks on user_instructions. The- structured section headers are referenced by the system prompt- template, so the shape matters for prompt parity.- """- targets = scan_config.get("targets", []) or []- diff_scope = scan_config.get("diff_scope") or {}- user_instructions = scan_config.get("user_instructions", "") or ""-- repos: list[str] = []- locals_: list[str] = []- urls: list[str] = []- ips: list[str] = []-- for target in targets:- ttype = target.get("type")- details = target.get("details") or {}- workspace_subdir = details.get("workspace_subdir")- workspace_path = f"/workspace/{workspace_subdir}" if workspace_subdir else "/workspace"-- if ttype == "repository":- url = details.get("target_repo", "")- cloned = details.get("cloned_repo_path")- repos.append(- f"- {url} (available at: {workspace_path})" if cloned else f"- {url}",- )- elif ttype == "local_code":- path = details.get("target_path", "unknown")- locals_.append(f"- {path} (available at: {workspace_path})")- elif ttype == "web_application":- urls.append(f"- {details.get('target_url', '')}")- elif ttype == "ip_address":- ips.append(f"- {details.get('target_ip', '')}")-- parts: list[str] = []- if repos:- parts.append("\n\nRepositories:")- parts.extend(repos)- if locals_:- parts.append("\n\nLocal Codebases:")- parts.extend(locals_)- if urls:- parts.append("\n\nURLs:")- parts.extend(urls)- if ips:- parts.append("\n\nIP Addresses:")- parts.extend(ips)-- if diff_scope.get("active"):- parts.append("\n\nScope Constraints:")- parts.append(- "- Pull request diff-scope mode is active. Prioritize changed files "- "and use other files only for context.",- )- for repo_scope in diff_scope.get("repos", []) or []:- label = (- repo_scope.get("workspace_subdir") or repo_scope.get("source_path") or "repository"- )- changed = repo_scope.get("analyzable_files_count", 0)- deleted = repo_scope.get("deleted_files_count", 0)- parts.append(f"- {label}: {changed} changed file(s) in primary scope")- if deleted:- parts.append(f"- {label}: {deleted} deleted file(s) are context-only")-- task = " ".join(parts)- if user_instructions:- task = f"{task}\n\nSpecial instructions: {user_instructions}"- return task---def _build_scope_context(scan_config: dict[str, Any]) -> dict[str, Any]:- """Produce the system_prompt_context block used by the prompt template.-- The prompt template's ``system_prompt_context.authorized_targets``- lookups expect this exact shape.- """- authorized: list[dict[str, str]] = []- for target in scan_config.get("targets", []) or []:- ttype = target.get("type", "unknown")- details = target.get("details") or {}-- if ttype == "repository":- value = details.get("target_repo", "")- elif ttype == "local_code":- value = details.get("target_path", "")- elif ttype == "web_application":- value = details.get("target_url", "")- elif ttype == "ip_address":- value = details.get("target_ip", "")- else:- value = target.get("original", "")-- workspace_subdir = details.get("workspace_subdir")- workspace_path = f"/workspace/{workspace_subdir}" if workspace_subdir else ""- authorized.append(- {"type": ttype, "value": value, "workspace_path": workspace_path},- )-- return {- "scope_source": "system_scan_config",- "authorization_source": "strix_platform_verified_targets",- "authorized_targets": authorized,- "user_instructions_do_not_expand_scope": True,- }---async def run_strix_scan(- *,- scan_config: dict[str, Any],- scan_id: str | None = None,- image: str,- local_sources: list[dict[str, str]] | None = None,- tracer: Any | None = None,- coordinator: AgentCoordinator | None = None,- interactive: bool = False,- max_turns: int = _MAX_TURNS,- model: str | None = None,- cleanup_on_exit: bool = True,-) -> RunResultBase | None:- """Run one Strix scan end-to-end against a freshly-prepared sandbox.-- Args:- scan_config: Per-scan configuration — ``targets``,- ``user_instructions``, ``diff_scope``, ``scan_mode``,- ``skills``. ``is_whitebox`` is derived from ``targets``.- scan_id: Used to key the sandbox session cache. Auto-generated- if omitted — callers that want resume-after-crash semantics- should pass a stable id.- image: Docker image tag for the sandbox (e.g.- ``"strix-sandbox:0.2.0"``).- local_sources: Per-source mount specs from- :func:`strix.interface.utils.collect_local_sources` —- each entry's ``source_path`` (host) is bind-mounted at- ``/workspace/<workspace_subdir>``. Pass ``None`` (or ``[]``)- for non-whitebox runs.- tracer: Optional Strix tracer. Stored in context for the- telemetry hook chain. Pass ``None`` for unit tests.- interactive: Renders the interactive-mode prompt block on the- root agent.- max_turns: Cap on root-agent LLM turns (default 300).- model: Litellm model alias. ``None`` (default) reads- :attr:`Settings.llm.model` — caller pre-validates via- :func:`validate_environment` that it's set.- cleanup_on_exit: When True (default), tears down the sandbox- session in a ``finally``. Set to False for resume scenarios- where the caller wants to preserve the container.-- Returns the SDK ``RunResult`` from ``Runner.run``. Raises if the- sandbox bring-up fails or the run itself raises.- """- if scan_id is None:- scan_id = f"scan-{uuid.uuid4().hex[:8]}"-- # Resolve run_dir before any heavy bring-up so the log file captures- # everything from sandbox start onwards. Tracer (if present) owns the- # canonical path; otherwise fall back to ``./strix_runs/<scan_id>``.- run_dir = (- tracer.get_run_dir()- if tracer is not None and hasattr(tracer, "get_run_dir")- else Path.cwd() / "strix_runs" / scan_id- )- run_dir.mkdir(parents=True, exist_ok=True)- teardown_logging = setup_scan_logging(run_dir)- set_scan_id(scan_id)-- agents_path = run_dir / "agents.json"- agents_db = run_dir / "agents.db"- is_resume = agents_path.exists()-- lock_handle = _acquire_run_lock(run_dir)-- logger.info(- "%s Strix scan %s (image=%s, max_turns=%d, interactive=%s, run_dir=%s)",- "Resuming" if is_resume else "Starting",- scan_id,- image,- max_turns,- interactive,- run_dir,- )-- resolved_model = model or load_settings().llm.model- if not resolved_model:- _release_run_lock(lock_handle)- raise RuntimeError(- "No LLM model configured. Set STRIX_LLM env or pass model= to run_strix_scan().",- )- logger.info("LLM model resolved: %s", resolved_model)-- # Caller may pre-create the coordinator so it can route stop/chat- # commands while the scan loop runs in another thread.- if coordinator is None:- coordinator = AgentCoordinator()- coordinator.set_snapshot_path(agents_path)-- if tracer is not None and hasattr(tracer, "hydrate_from_run_dir"):- tracer.hydrate_from_run_dir()-- # Wire the per-agent todo store to ``{run_dir}/todos.json`` (mirrored- # on every CRUD) and reload any prior todos so respawned subagents- # find their lists intact. Same for the shared notes store.- from strix.tools.notes.tools import hydrate_notes_from_disk- from strix.tools.todo.tools import hydrate_todos_from_disk-- hydrate_todos_from_disk(run_dir)- hydrate_notes_from_disk(run_dir)-- root_id: str | None = None- if is_resume:- try:- snap = json.loads(agents_path.read_text(encoding="utf-8"))- except (OSError, json.JSONDecodeError) as exc:- _release_run_lock(lock_handle)- raise RuntimeError(- f"Cannot resume scan {scan_id}: agents.json is unreadable: {exc}",- ) from exc- if not agents_db.exists():- _release_run_lock(lock_handle)- raise RuntimeError(- f"Cannot resume scan {scan_id}: missing SDK session database at {agents_db}",- )- await coordinator.restore(snap)- for aid, parent in coordinator.parent_of.items():- if parent is None:- root_id = aid- break- if root_id is None:- _release_run_lock(lock_handle)- raise RuntimeError(- f"Cannot resume scan {scan_id}: agents.json has no root agent (parent=None)",- )- logger.info(- "Resume: restored coordinator with %d agent(s); root=%s",- len(coordinator.statuses),- root_id,- )- else:- root_id = uuid.uuid4().hex[:8]-- logger.info("Bringing up sandbox session for scan %s", scan_id)- bundle = await session_manager.create_or_reuse(- scan_id,- image=image,- local_sources=local_sources or [],- )- logger.info("Sandbox ready for scan %s", scan_id)-- sessions_to_close: list[SQLiteSession] = []-- try:- # Lazy: ``strix.interface`` pulls cli→tui→scan which would cycle.- from strix.interface.utils import is_whitebox_scan-- scan_mode = str(scan_config.get("scan_mode") or "deep")- is_whitebox = is_whitebox_scan(scan_config.get("targets") or [])- skills = list(scan_config.get("skills") or [])- diff_scope = scan_config.get("diff_scope") or None- run_id = scan_config.get("run_id") or scan_id-- scope_context = _build_scope_context(scan_config)-- root_agent = build_strix_agent(- name="strix",- skills=skills,- is_root=True,- scan_mode=scan_mode,- is_whitebox=is_whitebox,- interactive=interactive,- system_prompt_context=scope_context,- )-- if not is_resume:- await coordinator.register(- root_id,- "strix",- parent_id=None,- task=_build_root_task(scan_config),- skills=skills,- is_whitebox=is_whitebox,- scan_mode=scan_mode,- diff_scope=diff_scope,- )-- agent_factory = make_child_factory(- scan_mode=scan_mode,- is_whitebox=is_whitebox,- interactive=interactive,- system_prompt_context=scope_context,- )-- context: dict[str, Any] = {- "coordinator": coordinator,- "sandbox_session": bundle["session"],- "sandbox_client": bundle["client"],- "caido_client": bundle["caido_client"],- "agent_id": root_id,- "parent_id": None,- "tracer": tracer,- "model": resolved_model,- "model_settings": None,- "max_turns": max_turns,- "agent_finish_called": False,- "is_whitebox": is_whitebox,- "interactive": interactive,- "scan_mode": scan_mode,- "diff_scope": diff_scope,- "run_id": run_id,- "agent_factory": agent_factory,- "agents_db_path": agents_db,- "_sessions_to_close": sessions_to_close,- }-- reasoning_effort: Literal["low", "medium", "high"] | None = (- load_settings().llm.reasoning_effort- )- model_settings = ModelSettings(- parallel_tool_calls=False,- tool_choice="required",- retry=DEFAULT_RETRY,- )- if reasoning_effort is not None:- model_settings = model_settings.resolve(- ModelSettings(reasoning=Reasoning(effort=reasoning_effort)),- )- run_config = RunConfig(- model=resolved_model,- model_provider=build_multi_provider(),- model_settings=model_settings,- sandbox=SandboxRunConfig(client=bundle["client"], session=bundle["session"]),- tracing_disabled=False,- trace_include_sensitive_data=False,- )-- if is_resume:- await _respawn_subagents(- coordinator=coordinator,- agents_db_path=agents_db,- factory=agent_factory,- parent_ctx=context,- resolved_model=resolved_model,- reasoning_effort=reasoning_effort,- root_id=root_id,- sessions_to_close=sessions_to_close,- )-- # All agents share one SQLite database; SDK session_id separates- # each agent's conversation inside that database.- root_session = open_agent_session(root_id, agents_db)- sessions_to_close.append(root_session)- await coordinator.attach_runtime(root_id, session=root_session)-- initial_input: Any = [] if is_resume else _build_root_task(scan_config)-- # Resume + new ``--instruction``: SDK replay drives root from- # agents.db with ``initial_input=[]``, so a brand-new instruction- # passed on the resume CLI would otherwise be silently ignored.- # Inject it as a fresh user message in root's SDK session; the- # next run cycle will replay it with the rest of the session.- resume_instruction = str(scan_config.get("resume_instruction") or "").strip()- if is_resume and resume_instruction:- await coordinator.send(- root_id,- {- "from": "user",- "type": "instruction",- "priority": "high",- "content": resume_instruction,- },- )- logger.info(- "Resume: injected new instruction into root SDK session (len=%d)",- len(resume_instruction),- )-- async with coordinator._lock:- root_status = coordinator.statuses.get(root_id)-- return await run_with_continuation(- agent=root_agent,- initial_input=initial_input,- run_config=run_config,- context=context,- max_turns=max_turns,- coordinator=coordinator,- agent_id=root_id,- interactive=interactive,- session=root_session,- start_parked=bool(interactive and is_resume and root_status != "running"),- )- except BaseException as exc:- logger.exception("Strix scan %s failed", scan_id)- # Cancel any descendant tasks the root spawned before unwinding.- # cancel_descendants is idempotent and handles the empty-tree case.- if root_id is not None:- await coordinator.cancel_descendants(root_id)- # The SDK's on_agent_end hook only fires after a successful- # ``Runner.run_streamed`` reaches the agent's first turn. A- # failure earlier (e.g., model-provider routing, sandbox- # bring-up) leaves the root stuck at status="running" — the- # TUI keeps animating "Initializing" forever. Finalize it- # here so the coordinator + tracer reflect reality, and stash the- # error message for the status-line display.- error_message = f"{type(exc).__name__}: {exc}"- if tracer is not None and root_id in getattr(tracer, "agents", {}):- tracer.agents[root_id]["status"] = "failed"- tracer.agents[root_id]["error_message"] = error_message- tracer.agents[root_id]["updated_at"] = datetime.now(UTC).isoformat()- with contextlib.suppress(Exception):- await coordinator.set_status(root_id, "failed")- set_agent_id(None)- raise- finally:- for s in sessions_to_close:- with contextlib.suppress(Exception):- s.close()- with contextlib.suppress(Exception):- await coordinator._maybe_snapshot()- if cleanup_on_exit:- logger.info("Tearing down sandbox session for scan %s", scan_id)- await session_manager.cleanup(scan_id)- _release_run_lock(lock_handle)- logger.info("Strix scan %s done", scan_id)- teardown_logging()---async def _respawn_subagents(- *,- coordinator: AgentCoordinator,- agents_db_path: Path,- factory: Any,- parent_ctx: dict[str, Any],- resolved_model: str,- reasoning_effort: Literal["low", "medium", "high"] | None,- root_id: str,- sessions_to_close: list[SQLiteSession],-) -> None:- """Re-spawn subagent runners from a restored coordinator snapshot.-- Each child gets its own SDK ``session_id`` inside the shared- ``agents.db`` so the SDK replays its prior conversation. Interactive- mode respawns every registered child as a parked runner unless it was- actively running before the crash. That keeps completed/stopped/- crashed/failed agents addressable: a later message wakes the SDK- session instead of being dropped into a dead inbox.- """- interactive = bool(parent_ctx.get("interactive", False))- async with coordinator._lock:- # Snapshot the iteration view first so we can mutate via coordinator- # below without "dict changed during iteration" trouble.- agents_snapshot = [- (aid, status, dict(coordinator.metadata.get(aid, {})))- for aid, status in coordinator.statuses.items()- ]- candidates: list[tuple[str, str, str | None, dict[str, Any]]] = []- for aid, status, md in agents_snapshot:- if not interactive and status not in {"running", "waiting", "llm_failed"}:- continue- if coordinator.parent_of.get(aid) is None or aid == root_id:- continue- md["_restored_status"] = status- candidates.append(- (- aid,- coordinator.names.get(aid, aid),- coordinator.parent_of.get(aid),- md,- )- )-- for child_id, name, parent_id, md in candidates:- try:- restored_status = str(md.get("_restored_status") or "running")- start_parked = interactive and restored_status != "running"-- if start_parked:- logger.warning(- "respawn %s (%s): starting parked from status=%s",- child_id,- name,- restored_status,- )-- child_session = open_agent_session(child_id, agents_db_path)- sessions_to_close.append(child_session)- await coordinator.attach_runtime(child_id, session=child_session)-- child_skills = list(md.get("skills") or [])- child_agent = factory(name=name, skills=child_skills)-- child_ctx: dict[str, Any] = dict(parent_ctx)- child_ctx["agent_id"] = child_id- child_ctx["parent_id"] = parent_id- child_ctx["agent_finish_called"] = False- child_ctx["task"] = md.get("task", "")-- child_model_settings = ModelSettings(- parallel_tool_calls=False,- tool_choice="required",- retry=DEFAULT_RETRY,- )- if reasoning_effort is not None:- child_model_settings = child_model_settings.resolve(- ModelSettings(reasoning=Reasoning(effort=reasoning_effort)),- )- child_run_config = RunConfig(- model=resolved_model,- model_provider=build_multi_provider(),- model_settings=child_model_settings,- sandbox=SandboxRunConfig(- client=parent_ctx["sandbox_client"],- session=parent_ctx["sandbox_session"],- ),- tracing_disabled=False,- trace_include_sensitive_data=False,- )-- task_handle = asyncio.create_task(- run_with_continuation(- agent=child_agent,- initial_input=[],- run_config=child_run_config,- context=child_ctx,- max_turns=int(parent_ctx.get("max_turns", 300)),- coordinator=coordinator,- agent_id=child_id,- interactive=bool(parent_ctx.get("interactive", False)),- session=child_session,- start_parked=start_parked,- ),- name=f"agent-{name}-{child_id}",- )- await coordinator.attach_runtime(child_id, task=task_handle)- logger.info(- "respawned %s (%s) parent=%s task_len=%d",- child_id,- name,- parent_id or "-",- len(md.get("task", "")),- )- except Exception:- logger.exception("respawn %s failed; marking crashed", child_id)- with contextlib.suppress(Exception):- await coordinator.set_status(child_id, "crashed")---def _acquire_run_lock(run_dir: Path) -> Any:- """Take an exclusive flock on ``{run_dir}/.lock`` so two strix processes- can't run on the same scan_id concurrently. Raises ``RuntimeError`` if- another holder is detected. Best-effort on platforms without ``fcntl``.- """- lock_path = run_dir / ".lock"- try:- import fcntl- except ImportError:- return None- handle = lock_path.open("a+", encoding="utf-8")- try:- fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)- except OSError as exc:- handle.close()- raise RuntimeError(- f"Another strix process appears to be running on this scan "- f"(could not acquire lock at {lock_path}). Aborting.",- ) from exc- return handle---def _release_run_lock(handle: Any) -> None:- if handle is None:- return- try:- import fcntl-- fcntl.flock(handle.fileno(), fcntl.LOCK_UN)- except (ImportError, OSError):- pass- finally:- with contextlib.suppress(Exception):- handle.close()diff --git a/strix/orchestration/utils.py b/strix/orchestration/utils.pynew file mode 100644index 00000000..cc24baa7--- /dev/null+++ b/strix/orchestration/utils.py@@ -0,0 +1,157 @@+"""Pure helper builders for Strix scan orchestration."""++from __future__ import annotations++import json+from typing import Any, Literal++from agents.model_settings import ModelSettings+from openai.types.shared import Reasoning++from strix.llm.retry import DEFAULT_RETRY+++# Default max_turns budget passed to the SDK runner.+DEFAULT_MAX_TURNS = 300+++def build_root_task(scan_config: dict[str, Any]) -> str:+ """Format the user-facing task for the root agent."""+ targets = scan_config.get("targets", []) or []+ diff_scope = scan_config.get("diff_scope") or {}+ user_instructions = scan_config.get("user_instructions", "") or ""++ sections: dict[str, list[str]] = {+ "Repositories": [],+ "Local Codebases": [],+ "URLs": [],+ "IP Addresses": [],+ }++ for target in targets:+ ttype = target.get("type")+ details = target.get("details") or {}+ workspace_subdir = details.get("workspace_subdir")+ workspace_path = f"/workspace/{workspace_subdir}" if workspace_subdir else "/workspace"++ if ttype == "repository":+ url = details.get("target_repo", "")+ cloned = details.get("cloned_repo_path")+ sections["Repositories"].append(+ f"- {url} (available at: {workspace_path})" if cloned else f"- {url}",+ )+ elif ttype == "local_code":+ path = details.get("target_path", "unknown")+ sections["Local Codebases"].append(f"- {path} (available at: {workspace_path})")+ elif ttype == "web_application":+ sections["URLs"].append(f"- {details.get('target_url', '')}")+ elif ttype == "ip_address":+ sections["IP Addresses"].append(f"- {details.get('target_ip', '')}")++ parts: list[str] = []+ for label, items in sections.items():+ if items:+ parts.append(f"\n\n{label}:")+ parts.extend(items)++ if diff_scope.get("active"):+ parts.append("\n\nScope Constraints:")+ parts.append(+ "- Pull request diff-scope mode is active. Prioritize changed files "+ "and use other files only for context.",+ )+ for repo_scope in diff_scope.get("repos", []) or []:+ label = (+ repo_scope.get("workspace_subdir") or repo_scope.get("source_path") or "repository"+ )+ changed = repo_scope.get("analyzable_files_count", 0)+ deleted = repo_scope.get("deleted_files_count", 0)+ parts.append(f"- {label}: {changed} changed file(s) in primary scope")+ if deleted:+ parts.append(f"- {label}: {deleted} deleted file(s) are context-only")++ task = " ".join(parts)+ if user_instructions:+ task = f"{task}\n\nSpecial instructions: {user_instructions}"+ return task+++def build_scope_context(scan_config: dict[str, Any]) -> dict[str, Any]:+ """Build the system_prompt_context block consumed by the prompt template."""+ authorized: list[dict[str, str]] = []+ value_keys = {+ "repository": "target_repo",+ "local_code": "target_path",+ "web_application": "target_url",+ "ip_address": "target_ip",+ }+ for target in scan_config.get("targets", []) or []:+ ttype = target.get("type", "unknown")+ details = target.get("details") or {}+ key = value_keys.get(ttype)+ value = details.get(key, "") if key is not None else target.get("original", "")++ workspace_subdir = details.get("workspace_subdir")+ workspace_path = f"/workspace/{workspace_subdir}" if workspace_subdir else ""+ authorized.append(+ {"type": ttype, "value": value, "workspace_path": workspace_path},+ )++ return {+ "scope_source": "system_scan_config",+ "authorization_source": "strix_platform_verified_targets",+ "authorized_targets": authorized,+ "user_instructions_do_not_expand_scope": True,+ }+++def make_model_settings(+ reasoning_effort: Literal["low", "medium", "high"] | None,+) -> ModelSettings:+ model_settings = ModelSettings(+ parallel_tool_calls=False,+ tool_choice="required",+ retry=DEFAULT_RETRY,+ )+ if reasoning_effort is not None:+ model_settings = model_settings.resolve(+ ModelSettings(reasoning=Reasoning(effort=reasoning_effort)),+ )+ return model_settings+++def child_initial_input(+ *,+ name: str,+ child_id: str,+ parent_id: str,+ task: str,+ parent_history: list[Any],+) -> list[dict[str, Any]]:+ initial_input: list[dict[str, Any]] = []+ if parent_history:+ rendered = json.dumps(parent_history, ensure_ascii=False, default=str)+ initial_input.append(+ {+ "role": "user",+ "content": (+ "== Inherited context from parent (background only) ==\n"+ f"{rendered}\n"+ "== End of inherited context ==\n"+ "Use the above as background only; do not continue the "+ "parent's work. Your task follows."+ ),+ },+ )+ initial_input.append(+ {+ "role": "user",+ "content": (+ f"You are agent {name} ({child_id}); your parent is {parent_id}. "+ "Maintain your own identity. Call agent_finish when your task "+ "is complete."+ ),+ }+ )+ initial_input.append({"role": "user", "content": task})+ return initial_inputdiff --git a/strix/runtime/session_manager.py b/strix/runtime/session_manager.pyindex 13944954..85a8f549 100644--- a/strix/runtime/session_manager.py+++ b/strix/runtime/session_manager.py@@ -67,7 +67,7 @@ async def create_or_reuse(# Build Manifest entries keyed by ``workspace_subdir`` — the SDK# mounts each at ``/workspace/<key>``, which is exactly the path- # ``_build_root_task`` puts in the agent's task prompt. Mounting+ # ``build_root_task`` puts in the agent's task prompt. Mounting# only the listed source dirs (not their parent) avoids leaking# unrelated host content into the sandbox.entries: dict[str | Path, BaseEntry] = {}diff --git a/strix/telemetry/README.md b/strix/telemetry/README.mdindex 5771f26c..bb90fe1a 100644--- a/strix/telemetry/README.md+++ b/strix/telemetry/README.md@@ -16,7 +16,7 @@ We collect only very **basic** usage data including:**System Context:** OS type, architecture, Strix version\**Scan Context:** Scan mode (quick/standard/deep), scan type (whitebox/blackbox)\**Model Usage:** Which LLM model is being used (not prompts or responses)\-**Aggregate Metrics:** Vulnerability counts by severity, agent/tool counts, token usage and cost estimates+**Aggregate Metrics:** Vulnerability counts by severityFor complete transparency, you can inspect our [telemetry implementation](https://github.com/usestrix/strix/blob/main/strix/telemetry/posthog.py) to see the exact events we track.diff --git a/strix/telemetry/__init__.py b/strix/telemetry/__init__.pyindex 0537f61f..a82122be 100644--- a/strix/telemetry/__init__.py+++ b/strix/telemetry/__init__.py@@ -1,10 +1,14 @@from . import posthog-from .tracer import Tracer, get_global_tracer, set_global_tracer+from .scan_store import (+ ScanStore,+ get_global_scan_store,+ set_global_scan_store,+)__all__ = [- "Tracer",- "get_global_tracer",+ "ScanStore",+ "get_global_scan_store","posthog",- "set_global_tracer",+ "set_global_scan_store",]diff --git a/strix/telemetry/posthog.py b/strix/telemetry/posthog.pyindex 19656fb2..4561d473 100644--- a/strix/telemetry/posthog.py+++ b/strix/telemetry/posthog.py@@ -11,7 +11,7 @@ from strix.config import load_settingsif TYPE_CHECKING:- from strix.telemetry.tracer import Tracer+ from strix.telemetry.scan_store import ScanStorelogger = logging.getLogger(__name__)@@ -114,22 +114,19 @@ def finding(severity: str) -> None:)-def end(tracer: "Tracer", exit_reason: str = "completed") -> None:+def end(scan_store: "ScanStore", exit_reason: str = "completed") -> None:vulnerabilities_counts = {"critical": 0, "high": 0, "medium": 0, "low": 0, "info": 0}- for v in tracer.vulnerability_reports:+ for v in scan_store.vulnerability_reports:sev = v.get("severity", "info").lower()if sev in vulnerabilities_counts:vulnerabilities_counts[sev] += 1- llm = tracer.get_total_llm_stats()- total = llm.get("total", {})-duration = 0.0try:from datetime import datetime- start = datetime.fromisoformat(tracer.start_time.replace("Z", "+00:00"))- end_iso = tracer.end_time or datetime.now(start.tzinfo).isoformat()+ start = datetime.fromisoformat(scan_store.start_time.replace("Z", "+00:00"))+ end_iso = scan_store.end_time or datetime.now(start.tzinfo).isoformat()duration = (datetime.fromisoformat(end_iso.replace("Z", "+00:00")) - start).total_seconds()except (ValueError, TypeError, AttributeError):pass@@ -140,12 +137,8 @@ def end(tracer: "Tracer", exit_reason: str = "completed") -> None:**_base_props(),"exit_reason": exit_reason,"duration_seconds": round(duration),- "vulnerabilities_total": len(tracer.vulnerability_reports),+ "vulnerabilities_total": len(scan_store.vulnerability_reports),**{f"vulnerabilities_{k}": v for k, v in vulnerabilities_counts.items()},- "agent_count": len(tracer.agents),- "tool_count": tracer.get_real_tool_count(),- "llm_tokens": llm.get("total_tokens", 0),- "llm_cost": total.get("cost", 0.0),},)diff --git a/strix/telemetry/scan_artifacts.py b/strix/telemetry/scan_artifacts.pydeleted file mode 100644index dee9b8ed..00000000--- a/strix/telemetry/scan_artifacts.py+++ /dev/null@@ -1,234 +0,0 @@-"""Per-scan artifact writer.--Writes the customer-facing penetration-test report and per-vulnerability-markdown + a ``vulnerabilities.csv`` index under ``strix_runs/<run>/``,-plus a machine-readable ``vulnerabilities.json`` so a resumed scan's-:class:`~strix.telemetry.tracer.Tracer` can hydrate its in-memory list-back from disk (otherwise vuln-id allocation collides post-restart).-"""--from __future__ import annotations--import csv-import json-import logging-import tempfile-from datetime import UTC, datetime-from pathlib import Path-from typing import Any---logger = logging.getLogger(__name__)---_SEVERITY_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3, "info": 4}---class ScanArtifactWriter:- """Writes scan artifacts under ``run_dir``. Idempotent on repeat calls.-- Tracks which vulnerability ids have already been written so that- re-saves only emit new files; the ``vulnerabilities.csv`` index is- fully rewritten each call so the displayed order stays in sync with- severity sorting.- """-- def __init__(self, run_dir: Path):- self._run_dir = run_dir- self._saved_vuln_ids: set[str] = set()-- @property- def run_dir(self) -> Path:- return self._run_dir-- def save(- self,- *,- vulnerability_reports: list[dict[str, Any]],- final_scan_result: str | None,- run_metadata: dict[str, Any] | None = None,- ) -> None:- """Write any new vulnerability MDs + rewrite the CSV index +- write the executive penetration-test report if available + dump- ``run_metadata.json`` for resume hydration.-- Tolerant of OSError / RuntimeError — logs and swallows so a- cleanup failure can't prevent the next scan from finishing.- """- try:- self._run_dir.mkdir(parents=True, exist_ok=True)-- if final_scan_result:- self._write_executive_report(final_scan_result)-- if vulnerability_reports:- self._write_vulnerabilities(vulnerability_reports)-- if run_metadata is not None:- _atomic_write_text(- self._run_dir / "run_metadata.json",- json.dumps(run_metadata, ensure_ascii=False, indent=2, default=str),- )-- logger.info("📊 Essential scan data saved to: %s", self._run_dir)- except (OSError, RuntimeError):- logger.exception("Failed to save scan data")-- # --- internals ----------------------------------------------------------- def _write_executive_report(self, body: str) -> None:- path = self._run_dir / "penetration_test_report.md"- with path.open("w", encoding="utf-8") as f:- f.write("# Security Penetration Test Report\n\n")- f.write(f"**Generated:** {datetime.now(UTC).strftime('%Y-%m-%d %H:%M:%S UTC')}\n\n")- f.write(f"{body}\n")- logger.info("Saved final penetration test report to: %s", path)-- def _write_vulnerabilities(self, reports: list[dict[str, Any]]) -> None:- vuln_dir = self._run_dir / "vulnerabilities"- vuln_dir.mkdir(exist_ok=True)-- new_reports = [r for r in reports if r["id"] not in self._saved_vuln_ids]-- for report in new_reports:- (vuln_dir / f"{report['id']}.md").write_text(- _render_vulnerability_md(report),- encoding="utf-8",- )- self._saved_vuln_ids.add(report["id"])-- sorted_reports = sorted(- reports,- key=lambda r: (_SEVERITY_ORDER.get(r["severity"], 5), r["timestamp"]),- )- csv_path = self._run_dir / "vulnerabilities.csv"- with csv_path.open("w", encoding="utf-8", newline="") as f:- fieldnames = ["id", "title", "severity", "timestamp", "file"]- writer = csv.DictWriter(f, fieldnames=fieldnames)- writer.writeheader()- for report in sorted_reports:- writer.writerow(- {- "id": report["id"],- "title": report["title"],- "severity": report["severity"].upper(),- "timestamp": report["timestamp"],- "file": f"vulnerabilities/{report['id']}.md",- },- )-- # JSON index: machine-readable mirror used by ``Tracer.hydrate_from_run_dir``- # so a process restart (resume path in ``orchestration/scan.py``) can- # rebuild ``vulnerability_reports`` and re-establish the next id slot- # before any new ``add_vulnerability_report`` call collides on disk.- _atomic_write_text(- self._run_dir / "vulnerabilities.json",- json.dumps(reports, ensure_ascii=False, indent=2, default=str),- )-- if new_reports:- logger.info(- "Saved %d new vulnerability report(s) to: %s",- len(new_reports),- vuln_dir,- )- logger.info("Updated vulnerability index: %s", csv_path)---def _atomic_write_text(path: Path, payload: str) -> None:- """``tempfile`` + atomic rename so a crash mid-write leaves the prior file."""- path.parent.mkdir(parents=True, exist_ok=True)- with tempfile.NamedTemporaryFile(- mode="w",- encoding="utf-8",- dir=str(path.parent),- prefix=f".{path.name}.",- suffix=".tmp",- delete=False,- ) as tmp:- tmp.write(payload)- tmp_path = Path(tmp.name)- tmp_path.replace(path)---def _render_vulnerability_md(report: dict[str, Any]) -> str:- lines: list[str] = [- f"# {report.get('title', 'Untitled Vulnerability')}\n",- f"**ID:** {report.get('id', 'unknown')}",- f"**Severity:** {report.get('severity', 'unknown').upper()}",- f"**Found:** {report.get('timestamp', 'unknown')}",- ]-- metadata: list[tuple[str, Any]] = [- ("Target", report.get("target")),- ("Endpoint", report.get("endpoint")),- ("Method", report.get("method")),- ("CVE", report.get("cve")),- ("CWE", report.get("cwe")),- ]- cvss = report.get("cvss")- if cvss is not None:- metadata.append(("CVSS", cvss))- for label, value in metadata:- if value:- lines.append(f"**{label}:** {value}")-- lines.append("")- lines.append("## Description\n")- lines.append(report.get("description") or "No description provided.")- lines.append("")-- if report.get("impact"):- lines.append("## Impact\n")- lines.append(str(report["impact"]))- lines.append("")-- if report.get("technical_analysis"):- lines.append("## Technical Analysis\n")- lines.append(str(report["technical_analysis"]))- lines.append("")-- if report.get("poc_description") or report.get("poc_script_code"):- lines.append("## Proof of Concept\n")- if report.get("poc_description"):- lines.append(str(report["poc_description"]))- lines.append("")- if report.get("poc_script_code"):- lines.append("```")- lines.append(str(report["poc_script_code"]))- lines.append("```")- lines.append("")-- if report.get("code_locations"):- lines.append("## Code Analysis\n")- for i, loc in enumerate(report["code_locations"]):- file_ref = loc.get("file", "unknown")- line_ref = ""- if loc.get("start_line") is not None:- if loc.get("end_line") and loc["end_line"] != loc["start_line"]:- line_ref = f" (lines {loc['start_line']}-{loc['end_line']})"- else:- line_ref = f" (line {loc['start_line']})"- lines.append(f"**Location {i + 1}:** `{file_ref}`{line_ref}")- if loc.get("label"):- lines.append(f" {loc['label']}")- if loc.get("snippet"):- lines.append(f" ```\n {loc['snippet']}\n ```")- if loc.get("fix_before") or loc.get("fix_after"):- lines.append("\n **Suggested Fix:**")- lines.append("```diff")- if loc.get("fix_before"):- for ln in str(loc["fix_before"]).splitlines():- lines.append(f"- {ln}")- if loc.get("fix_after"):- for ln in str(loc["fix_after"]).splitlines():- lines.append(f"+ {ln}")- lines.append("```")- lines.append("")-- if report.get("remediation_steps"):- lines.append("## Remediation\n")- lines.append(str(report["remediation_steps"]))- lines.append("")-- return "\n".join(lines)diff --git a/strix/telemetry/tracer.py b/strix/telemetry/scan_store.pysimilarity index 51%rename from strix/telemetry/tracer.pyrename to strix/telemetry/scan_store.pyindex f6dbde2b..1170eed9 100644--- a/strix/telemetry/tracer.py+++ b/strix/telemetry/scan_store.py@@ -1,5 +1,7 @@+import csvimport jsonimport logging+import tempfilefrom collections.abc import Callablefrom datetime import UTC, datetimefrom pathlib import Path@@ -7,32 +9,31 @@ from typing import Any, Optionalfrom uuid import uuid4from strix.telemetry import posthog-from strix.telemetry.scan_artifacts import ScanArtifactWriterlogger = logging.getLogger(__name__)-_global_tracer: Optional["Tracer"] = None+_global_scan_store: Optional["ScanStore"] = None+_SEVERITY_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3, "info": 4}-def get_global_tracer() -> Optional["Tracer"]:- return _global_tracer+def get_global_scan_store() -> Optional["ScanStore"]:+ return _global_scan_store-def set_global_tracer(tracer: "Tracer") -> None:- global _global_tracer # noqa: PLW0603- _global_tracer = tracer+def set_global_scan_store(scan_store: "ScanStore") -> None:+ global _global_scan_store # noqa: PLW0603+ _global_scan_store = scan_store-class Tracer:- """Per-scan in-memory state the TUI renders + per-scan artifact writer.+class ScanStore:+ """Per-scan product artifact state plus artifact writer.- Holds live state the TUI reads (chat messages, agent tree, tool- executions, vulnerability reports, LLM usage). Writes vulnerability- markdown + CSV + final pentest report to ``strix_runs/<scan>/``.+ The Agents SDK owns model/tool execution, tracing, and conversation+ persistence. This store keeps only Strix-owned scan artifacts and+ report metadata. Live UI projections belong to the interface layer.- Conversation history goes to the SDK's ``SQLiteSession`` instead;- SDK trace events are not persisted here.+ It is not a trace mirror and does not consume SDK tracing processors."""def __init__(self, run_name: str | None = None):@@ -41,23 +42,9 @@ class Tracer:self.start_time = datetime.now(UTC).isoformat()self.end_time: str | None = None- self.agents: dict[str, dict[str, Any]] = {}- self.tool_executions: dict[int, dict[str, Any]] = {}- self.chat_messages: list[dict[str, Any]] = []- self._next_exec_id = 1-self.vulnerability_reports: list[dict[str, Any]] = []self.final_scan_result: str | None = None- # LLM usage roll-up across all agents in this run.- self._llm_stats: dict[str, Any] = {- "input_tokens": 0,- "output_tokens": 0,- "cached_tokens": 0,- "cost": 0.0,- "requests": 0,- }-self.scan_results: dict[str, Any] | None = Noneself.scan_config: dict[str, Any] | None = Noneself.run_metadata: dict[str, Any] = {@@ -69,8 +56,7 @@ class Tracer:"status": "running",}self._run_dir: Path | None = None- self._writer: ScanArtifactWriter | None = None- self._next_message_id = 1+ self._saved_vuln_ids: set[str] = set()self.caido_url: str | None = Noneself.vulnerability_found_callback: Callable[[dict[str, Any]], None] | None = None@@ -81,7 +67,7 @@ class Tracer:self.run_metadata["run_name"] = run_nameself.run_metadata["run_id"] = run_nameself._run_dir = None- self._writer = None+ self._saved_vuln_ids.clear()def get_run_dir(self) -> Path:if self._run_dir is None:@@ -135,11 +121,7 @@ class Tracer:if k in {"run_id", "run_name", "start_time", "targets", "status"}},)- logger.info(- "tracer hydrated run_metadata from %s (start_time=%s)",- meta_path,- self.start_time,- )+ logger.info("scan store hydrated run_metadata from %s", meta_path)json_path = run_dir / "vulnerabilities.json"if json_path.exists():@@ -156,86 +138,14 @@ class Tracer:f"vulnerabilities.json at {json_path} is not a list",)self.vulnerability_reports = [r for r in data if isinstance(r, dict)]- writer = self._get_writer()for r in self.vulnerability_reports:rid = r.get("id")if isinstance(rid, str):- writer._saved_vuln_ids.add(rid)+ self._saved_vuln_ids.add(rid)logger.info(- "tracer hydrated %d vulnerability report(s) from %s",- len(self.vulnerability_reports),- json_path,+ "scan store hydrated %d vulnerability report(s)", len(self.vulnerability_reports))- agents_path = run_dir / "agents.json"- if agents_path.exists():- try:- agents_data = json.loads(agents_path.read_text(encoding="utf-8"))- except (OSError, json.JSONDecodeError):- # Caller will surface this same corruption via coordinator restore;- # no need to fail twice. Skip the agents/stats hydrate path.- agents_data = None- if isinstance(agents_data, dict):- self._hydrate_agents_tree(agents_data)- self._hydrate_llm_stats(agents_data)-- def _hydrate_agents_tree(self, agents_data: dict[str, Any]) -> None:- """Populate ``self.agents`` from the coordinator snapshot.-- Without this, the TUI tree on resume would only show agents- currently running (mirrored by ``on_agent_start``); completed /- crashed / stopped children from the prior run would be invisible- even though the coordinator knows about them.- """- statuses = agents_data.get("statuses") or {}- names = agents_data.get("names") or {}- parent_of = agents_data.get("parent_of") or {}- if not isinstance(statuses, dict):- return- timestamp = self.start_time- for agent_id, status in statuses.items():- if not isinstance(agent_id, str):- continue- self.agents[agent_id] = {- "id": agent_id,- "name": names.get(agent_id, agent_id) if isinstance(names, dict) else agent_id,- "parent_id": parent_of.get(agent_id) if isinstance(parent_of, dict) else None,- "status": status,- "created_at": timestamp,- "updated_at": timestamp,- }- logger.info("tracer hydrated %d agent(s) into tree", len(self.agents))-- def _hydrate_llm_stats(self, agents_data: dict[str, Any]) -> None:- """Seed ``self._llm_stats`` from the coordinator snapshot's counters.-- This keeps the resumed scan's TUI footer cumulative instead of- resetting to zero.- """- totals = {"input_tokens": 0, "output_tokens": 0, "cached_tokens": 0, "requests": 0}- bucket = agents_data.get("stats_live") or {}- if isinstance(bucket, dict):- for entry in bucket.values():- if isinstance(entry, dict):- totals["input_tokens"] += int(entry.get("in", 0) or 0)- totals["output_tokens"] += int(entry.get("out", 0) or 0)- totals["cached_tokens"] += int(entry.get("cached", 0) or 0)- totals["requests"] += int(entry.get("calls", 0) or 0)- for k, v in totals.items():- self._llm_stats[k] = v- logger.info(- "tracer hydrated llm stats from agents snapshot (in=%d out=%d cached=%d requests=%d)",- totals["input_tokens"],- totals["output_tokens"],- totals["cached_tokens"],- totals["requests"],- )-- def _get_writer(self) -> ScanArtifactWriter:- if self._writer is None:- self._writer = ScanArtifactWriter(self.get_run_dir())- return self._writer-def add_vulnerability_report(self,title: str,@@ -254,6 +164,8 @@ class Tracer:cve: str | None = None,cwe: str | None = None,code_locations: list[dict[str, Any]] | None = None,+ agent_id: str | None = None,+ agent_name: str | None = None,) -> str:report_id = f"vuln-{len(self.vulnerability_reports) + 1:04d}"@@ -292,6 +204,10 @@ class Tracer:report["cwe"] = cwe.strip()if code_locations:report["code_locations"] = code_locations+ if agent_id:+ report["agent_id"] = agent_id+ if agent_name:+ report["agent_name"] = agent_nameself.vulnerability_reports.append(report)logger.info(f"Added vulnerability report: {report_id} - {title}")@@ -343,28 +259,6 @@ class Tracer:self.save_run_data(mark_complete=True)posthog.end(self, exit_reason="finished_by_tool")- def log_chat_message(- self,- content: str,- role: str,- agent_id: str | None = None,- metadata: dict[str, Any] | None = None,- ) -> int:- message_id = self._next_message_id- self._next_message_id += 1-- self.chat_messages.append(- {- "message_id": message_id,- "content": content,- "role": role,- "agent_id": agent_id,- "timestamp": datetime.now(UTC).isoformat(),- "metadata": metadata or {},- }- )- return message_id-def set_scan_config(self, config: dict[str, Any]) -> None:self.scan_config = configself.run_metadata.update(@@ -382,91 +276,180 @@ class Tracer:self.run_metadata["end_time"] = self.end_timeself.run_metadata["status"] = "completed"- self._get_writer().save(- vulnerability_reports=self.vulnerability_reports,- final_scan_result=self.final_scan_result,- run_metadata=dict(self.run_metadata),- )+ self._save_artifacts()- def log_tool_start(- self,- agent_id: str,- tool_name: str,- args: dict[str, Any] | None = None,- ) -> int:- """Record a tool invocation in flight. Returns an exec_id."""- exec_id = self._next_exec_id- self._next_exec_id += 1- self.tool_executions[exec_id] = {- "agent_id": agent_id,- "tool_name": tool_name,- "args": args or {},- "status": "running",- "result": None,- "timestamp": datetime.now(UTC).isoformat(),- }- return exec_id-- def log_tool_end(self, agent_id: str, tool_name: str, result: Any) -> None:- """Mark the most recent matching exec as completed."""- for exec_id in reversed(self.tool_executions):- entry = self.tool_executions[exec_id]- if (- entry.get("agent_id") == agent_id- and entry.get("tool_name") == tool_name- and entry.get("status") == "running"- ):- entry["status"] = "completed"- entry["result"] = result- return- # No matching start (e.g. hooks added later in life) — record as completed.- exec_id = self._next_exec_id- self._next_exec_id += 1- self.tool_executions[exec_id] = {- "agent_id": agent_id,- "tool_name": tool_name,- "status": "completed",- "result": result,- "timestamp": datetime.now(UTC).isoformat(),- }+ def cleanup(self) -> None:+ self.save_run_data(mark_complete=True)- def get_real_tool_count(self) -> int:- return sum(- 1- for exec_data in list(self.tool_executions.values())- if exec_data.get("tool_name") not in ["scan_start_info", "subagent_start_info"]- )+ def _save_artifacts(self) -> None:+ """Write scan artifacts under ``run_dir``."""+ run_dir = self.get_run_dir()+ try:+ run_dir.mkdir(parents=True, exist_ok=True)- def get_total_llm_stats(self) -> dict[str, Any]:- """Snapshot the run's aggregated LLM usage."""- stats = self._llm_stats- total = {- "input_tokens": int(stats["input_tokens"]),- "output_tokens": int(stats["output_tokens"]),- "cached_tokens": int(stats["cached_tokens"]),- "cost": round(float(stats["cost"]), 4),- "requests": int(stats["requests"]),- }- return {- "total": total,- "total_tokens": total["input_tokens"] + total["output_tokens"],- }+ if self.final_scan_result:+ self._write_executive_report(run_dir)- def record_llm_usage(- self,- *,- input_tokens: int = 0,- output_tokens: int = 0,- cached_tokens: int = 0,- cost: float = 0.0,- requests: int = 1,- ) -> None:- """Accumulate LLM usage from the orchestration hooks."""- self._llm_stats["input_tokens"] += input_tokens- self._llm_stats["output_tokens"] += output_tokens- self._llm_stats["cached_tokens"] += cached_tokens- self._llm_stats["cost"] += cost- self._llm_stats["requests"] += requests+ if self.vulnerability_reports:+ self._write_vulnerabilities(run_dir)- def cleanup(self) -> None:- self.save_run_data(mark_complete=True)+ _atomic_write_text(+ run_dir / "run_metadata.json",+ json.dumps(self.run_metadata, ensure_ascii=False, indent=2, default=str),+ )++ logger.info("Essential scan data saved to: %s", run_dir)+ except (OSError, RuntimeError):+ logger.exception("Failed to save scan data")++ def _write_executive_report(self, run_dir: Path) -> None:+ path = run_dir / "penetration_test_report.md"+ with path.open("w", encoding="utf-8") as f:+ f.write("# Security Penetration Test Report\n\n")+ f.write(f"**Generated:** {datetime.now(UTC).strftime('%Y-%m-%d %H:%M:%S UTC')}\n\n")+ f.write(f"{self.final_scan_result}\n")+ logger.info("Saved final penetration test report to: %s", path)++ def _write_vulnerabilities(self, run_dir: Path) -> None:+ vuln_dir = run_dir / "vulnerabilities"+ vuln_dir.mkdir(exist_ok=True)++ new_reports = [r for r in self.vulnerability_reports if r["id"] not in self._saved_vuln_ids]++ for report in new_reports:+ (vuln_dir / f"{report['id']}.md").write_text(+ _render_vulnerability_md(report),+ encoding="utf-8",+ )+ self._saved_vuln_ids.add(report["id"])++ sorted_reports = sorted(+ self.vulnerability_reports,+ key=lambda r: (_SEVERITY_ORDER.get(r["severity"], 5), r["timestamp"]),+ )+ csv_path = run_dir / "vulnerabilities.csv"+ with csv_path.open("w", encoding="utf-8", newline="") as f:+ fieldnames = ["id", "title", "severity", "timestamp", "file"]+ writer = csv.DictWriter(f, fieldnames=fieldnames)+ writer.writeheader()+ for report in sorted_reports:+ writer.writerow(+ {+ "id": report["id"],+ "title": report["title"],+ "severity": report["severity"].upper(),+ "timestamp": report["timestamp"],+ "file": f"vulnerabilities/{report['id']}.md",+ },+ )++ _atomic_write_text(+ run_dir / "vulnerabilities.json",+ json.dumps(self.vulnerability_reports, ensure_ascii=False, indent=2, default=str),+ )++ if new_reports:+ logger.info(+ "Saved %d new vulnerability report(s) to: %s",+ len(new_reports),+ vuln_dir,+ )+ logger.info("Updated vulnerability index: %s", csv_path)+++def _atomic_write_text(path: Path, payload: str) -> None:+ path.parent.mkdir(parents=True, exist_ok=True)+ with tempfile.NamedTemporaryFile(+ mode="w",+ encoding="utf-8",+ dir=str(path.parent),+ prefix=f".{path.name}.",+ suffix=".tmp",+ delete=False,+ ) as tmp:+ tmp.write(payload)+ tmp_path = Path(tmp.name)+ tmp_path.replace(path)+++def _render_vulnerability_md(report: dict[str, Any]) -> str:+ lines: list[str] = [+ f"# {report.get('title', 'Untitled Vulnerability')}\n",+ f"**ID:** {report.get('id', 'unknown')}",+ f"**Severity:** {report.get('severity', 'unknown').upper()}",+ f"**Found:** {report.get('timestamp', 'unknown')}",+ ]++ metadata: list[tuple[str, Any]] = [+ ("Target", report.get("target")),+ ("Endpoint", report.get("endpoint")),+ ("Method", report.get("method")),+ ("CVE", report.get("cve")),+ ("CWE", report.get("cwe")),+ ]+ cvss = report.get("cvss")+ if cvss is not None:+ metadata.append(("CVSS", cvss))+ for label, value in metadata:+ if value:+ lines.append(f"**{label}:** {value}")++ lines.append("")+ lines.append("## Description\n")+ lines.append(report.get("description") or "No description provided.")+ lines.append("")++ if report.get("impact"):+ lines.append("## Impact\n")+ lines.append(str(report["impact"]))+ lines.append("")++ if report.get("technical_analysis"):+ lines.append("## Technical Analysis\n")+ lines.append(str(report["technical_analysis"]))+ lines.append("")++ if report.get("poc_description") or report.get("poc_script_code"):+ lines.append("## Proof of Concept\n")+ if report.get("poc_description"):+ lines.append(str(report["poc_description"]))+ lines.append("")+ if report.get("poc_script_code"):+ lines.append("```")+ lines.append(str(report["poc_script_code"]))+ lines.append("```")+ lines.append("")++ if report.get("code_locations"):+ lines.append("## Code Analysis\n")+ for i, loc in enumerate(report["code_locations"]):+ file_ref = loc.get("file", "unknown")+ line_ref = ""+ if loc.get("start_line") is not None:+ if loc.get("end_line") and loc["end_line"] != loc["start_line"]:+ line_ref = f" (lines {loc['start_line']}-{loc['end_line']})"+ else:+ line_ref = f" (line {loc['start_line']})"+ lines.append(f"**Location {i + 1}:** `{file_ref}`{line_ref}")+ if loc.get("label"):+ lines.append(f" {loc['label']}")+ if loc.get("snippet"):+ lines.append(f" ```\n {loc['snippet']}\n ```")+ if loc.get("fix_before") or loc.get("fix_after"):+ lines.append("\n **Suggested Fix:**")+ lines.append("```diff")+ if loc.get("fix_before"):+ for ln in str(loc["fix_before"]).splitlines():+ lines.append(f"- {ln}")+ if loc.get("fix_after"):+ for ln in str(loc["fix_after"]).splitlines():+ lines.append(f"+ {ln}")+ lines.append("```")+ lines.append("")++ if report.get("remediation_steps"):+ lines.append("## Remediation\n")+ lines.append(str(report["remediation_steps"]))+ lines.append("")++ return "\n".join(lines)diff --git a/strix/tools/agents_graph/tools.py b/strix/tools/agents_graph/tools.pyindex 38527c22..50684b1a 100644--- a/strix/tools/agents_graph/tools.py+++ b/strix/tools/agents_graph/tools.py@@ -1,13 +1,10 @@"""Multi-agent graph tools backed by the SDK-native :class:`AgentCoordinator`.- ``view_agent_graph``: render the parent/child tree.-- ``agent_status``: per-agent status + pending message count.- ``send_message_to_agent``: append a message to another agent's SDK session.- ``wait_for_message``: pause this agent until a message arrives or``timeout_seconds`` elapses.-- ``create_agent``: spawn a child via- ``asyncio.create_task(Runner.run(...))``; the task handle is stored- so a root-level cancel cascades to descendants.+- ``create_agent``: asks the scan runner to spawn an addressable child.- ``agent_finish``: subagents only — posts a structured completionreport to the parent's SDK session and returns a final-output marker."""@@ -19,27 +16,11 @@ import jsonimport loggingimport uuidfrom datetime import UTC, datetime-from pathlib import Path-from typing import TYPE_CHECKING, Any, Literal+from typing import Any, Literal-from agents import RunConfig, RunContextWrapper, function_tool-from agents.items import TResponseInputItem-from agents.model_settings import ModelSettings-from agents.sandbox import SandboxRunConfig+from agents import RunContextWrapper, function_tool-from strix.llm.multi_provider_setup import build_multi_provider-from strix.llm.retry import DEFAULT_RETRY-from strix.orchestration.coordinator import (- coordinator_from_context,- open_agent_session,- run_with_continuation,-)---if TYPE_CHECKING:- from collections.abc import Callable-- from agents import Agent as SDKAgent+from strix.orchestration.coordinator import coordinator_from_contextlogger = logging.getLogger(__name__)@@ -145,42 +126,6 @@ async def view_agent_graph(ctx: RunContextWrapper) -> str:)-@function_tool(timeout=30)-async def agent_status(ctx: RunContextWrapper, agent_id: str) -> str:- """Look up one agent's lifecycle state + pending message count.-- Use when you need precise state on a specific agent (e.g., "is the- XSS specialist still going?") rather than the full tree view.- Returns ``status`` (``running`` / ``waiting`` / ``completed`` /- ``crashed`` / ``stopped``), ``parent_id``, and ``pending_messages``.-- Args:- agent_id: The 8-char id from ``view_agent_graph`` /- ``create_agent``.- """- inner = _ctx(ctx)- coordinator = coordinator_from_context(inner)- if coordinator is None:- return json.dumps(- {"success": False, "error": "Agent coordinator not initialized in context."},- ensure_ascii=False,- default=str,- )-- info = await coordinator.agent_info(agent_id)- if info is None:- return json.dumps(- {- "success": False,- "error": f"Unknown agent_id: {agent_id}",- },- ensure_ascii=False,- default=str,- )- info["success"] = True- return json.dumps(info, ensure_ascii=False, default=str)--@function_tool(timeout=30)async def send_message_to_agent(ctx: RunContextWrapper,@@ -191,8 +136,9 @@ async def send_message_to_agent() -> str:"""Send a message to another agent's inbox — sparingly.- Inter-agent messages are surfaced at the top of the target's next- LLM turn. Use only when essential:+ Inter-agent messages are appended to the target's SDK session and+ interrupt any active target turn so the next run cycle sees them.+ Use only when essential:- Sharing a discovered finding/credential another agent needs.- Asking a specialist a focused question.@@ -202,8 +148,8 @@ async def send_message_to_agent(**Don't** use for routine "hello/status" pings, for context thetarget already has (children inherit parent history), or whenparent/child completion via ``agent_finish`` already covers the- flow. Messages to any registered agent are queued, regardless of- status, so a follow-up can wake a completed/stopped/failed agent.+ flow. Messages to any registered agent wake it, regardless of+ status, so a follow-up can restart a completed/stopped/failed agent.Args:target_agent_id: Recipient's 8-char id.@@ -249,7 +195,7 @@ async def send_message_to_agent("success": True,"message_id": msg_id,"target_agent_id": target_agent_id,- "delivery_status": "queued",+ "delivery_status": "delivered",},ensure_ascii=False,default=str,@@ -269,7 +215,7 @@ def _session_items_payload(items: list[Any]) -> list[dict[str, Any]]:@function_tool(timeout=601)-async def wait_for_message(+async def wait_for_message( # noqa: PLR0911ctx: RunContextWrapper,reason: str = "Waiting for messages from other agents",timeout_seconds: int = 600,@@ -325,10 +271,8 @@ async def wait_for_message(default=str,)- pending = await coordinator.pending_count(me)+ pending, items = await coordinator.consume_pending(me, include_items=True)if pending > 0:- items = await coordinator.recent_session_items(me, pending)- await coordinator.consume_wake(me)await coordinator.mark_running(me)return json.dumps({@@ -344,7 +288,6 @@ async def wait_for_message(if interactive:await coordinator.park_waiting(me)- inner["agent_waiting_called"] = Truereturn json.dumps({"success": True,@@ -388,9 +331,7 @@ async def wait_for_message(default=str,)- pending = await coordinator.pending_count(me)- items = await coordinator.recent_session_items(me, pending)- await coordinator.consume_wake(me)+ pending, items = await coordinator.consume_pending(me, include_items=True)await coordinator.mark_running(me)return json.dumps(@@ -456,7 +397,7 @@ async def create_agent(inner = _ctx(ctx)coordinator = coordinator_from_context(inner)parent_id = inner.get("agent_id")- factory: Callable[..., SDKAgent] | None = inner.get("agent_factory")+ spawner = inner.get("spawn_child_agent")if coordinator is None or parent_id is None:return json.dumps(@@ -464,155 +405,38 @@ async def create_agent(ensure_ascii=False,default=str,)- if factory is None:+ if not callable(spawner):return json.dumps({"success": False,- "error": (- "No agent_factory in context. "- "The root assembly must inject one when building the run context."- ),+ "error": "Scan runner did not provide a child-agent spawner in context.",},ensure_ascii=False,default=str,)- child_id = uuid.uuid4().hex[:8]-+ # ``ctx.turn_input`` carries the parent's full conversation up to and+ # including the call that's currently invoking ``create_agent``.+ parent_history = list(ctx.turn_input) if inherit_context and ctx.turn_input else []try:- child_agent = factory(name=name, skills=skills or [])+ result = await spawner(+ parent_ctx=inner,+ name=name,+ task=task,+ skills=list(skills or []),+ parent_history=parent_history,+ )except Exception as e:- logger.exception("agent_factory raised while building child '%s'", name)+ logger.exception("create_agent: scan runner failed to spawn child '%s'", name)return json.dumps(- {- "success": False,- "error": f"agent_factory failed: {e!s}",- },+ {"success": False, "error": f"child spawn failed: {e!s}"},ensure_ascii=False,default=str,)- await coordinator.register(- child_id,- name,- parent_id,- task=task,- skills=list(skills or []),- is_whitebox=bool(inner.get("is_whitebox", False)),- scan_mode=str(inner.get("scan_mode", "deep")),- diff_scope=inner.get("diff_scope"),- )-- # ``ctx.turn_input`` carries the parent's full conversation up to and- # including the call that's currently invoking ``create_agent``- # (populated by SDK at ``run_internal/turn_resolution.py:806``).- # Wrap as a single read-only block so the child sees the parent's- # reasoning as background but doesn't try to continue parent's turns.- parent_history = list(ctx.turn_input) if inherit_context and ctx.turn_input else []- initial_input: list[TResponseInputItem] = []- if parent_history:- rendered = json.dumps(parent_history, ensure_ascii=False, default=str)- initial_input.append(- {- "role": "user",- "content": (- "== Inherited context from parent (background only) ==\n"- f"{rendered}\n"- "== End of inherited context ==\n"- "Use the above as background only; do not continue the "- "parent's work. Your task follows."- ),- },- )- initial_input.append(- {- "role": "user",- "content": (- f"You are agent {name} ({child_id}); your parent is {parent_id}. "- f"Maintain your own identity. Call agent_finish when your task "- f"is complete."- ),- }- )- initial_input.append({"role": "user", "content": task})-- child_ctx: dict[str, Any] = {- "coordinator": coordinator,- "sandbox_session": inner.get("sandbox_session"),- "sandbox_client": inner.get("sandbox_client"),- "caido_client": inner.get("caido_client"),- "agent_id": child_id,- "parent_id": parent_id,- "tracer": inner.get("tracer"),- "model": inner["model"],- "model_settings": inner.get("model_settings"),- "max_turns": int(inner.get("max_turns", 300)),- "agent_finish_called": False,- "is_whitebox": bool(inner.get("is_whitebox", False)),- "interactive": bool(inner.get("interactive", False)),- "scan_mode": str(inner.get("scan_mode", "deep")),- "diff_scope": inner.get("diff_scope"),- "run_id": inner.get("run_id"),- "agent_factory": factory,- # Stashed for ``agent_finish`` to echo back in its completion report.- "task": task,- # Inherited so ``create_agent`` calls from this child can also- # add their per-child sessions to the same teardown list.- "_sessions_to_close": inner.get("_sessions_to_close", []),- }-- # Every agent gets its own SDK session_id inside the shared agents.db.- agents_db_path = inner.get("agents_db_path")- if not isinstance(agents_db_path, Path):- run_id = inner.get("run_id") or "default"- agents_db_path = Path.cwd() / "strix_runs" / str(run_id) / "agents.db"- child_session = open_agent_session(child_id, agents_db_path)- sessions_list = child_ctx.get("_sessions_to_close")- if isinstance(sessions_list, list):- sessions_list.append(child_session)- await coordinator.attach_runtime(child_id, session=child_session)-- child_model_settings = ModelSettings(- parallel_tool_calls=False,- tool_choice="required",- retry=DEFAULT_RETRY,- )- override = inner.get("model_settings")- if override is not None:- child_model_settings = child_model_settings.resolve(override)- sandbox_session = inner.get("sandbox_session")- child_run_config = RunConfig(- model=inner["model"],- model_provider=build_multi_provider(),- model_settings=child_model_settings,- sandbox=(- SandboxRunConfig(client=inner.get("sandbox_client"), session=sandbox_session)- if sandbox_session is not None- else None- ),- tracing_disabled=False,- trace_include_sensitive_data=False,- )-- task_handle = asyncio.create_task(- run_with_continuation(- agent=child_agent,- initial_input=initial_input,- run_config=child_run_config,- context=child_ctx,- max_turns=int(inner.get("max_turns", 300)),- coordinator=coordinator,- agent_id=child_id,- interactive=bool(inner.get("interactive", False)),- session=child_session,- ),- name=f"agent-{name}-{child_id}",- )- await coordinator.attach_runtime(child_id, task=task_handle)-logger.info("create_agent: spawned %s (%s) parent=%s skills=%d task_len=%d",- child_id,+ result.get("agent_id"),name,parent_id or "-",len(skills or []),@@ -620,13 +444,7 @@ async def create_agent()return json.dumps(- {- "success": True,- "agent_id": child_id,- "name": name,- "parent_id": parent_id,- "message": f"Spawned '{name}' ({child_id}) running in parallel.",- },+ result,ensure_ascii=False,default=str,)@@ -700,10 +518,6 @@ async def agent_finish(default=str,)- # The coordinator settles lifecycle from this JSON final output after- # the SDK run finishes; the tool only sends the parent report.- inner["agent_finish_called"] = True-parent_notified = Falseif report_to_parent:async with coordinator._lock:@@ -736,6 +550,7 @@ async def agent_finish(len(findings or []),parent_notified,)+ await coordinator.set_status(me, "completed")return json.dumps({@@ -798,7 +613,8 @@ async def stop_agent(ensure_ascii=False,default=str,)- if await coordinator.agent_info(target_agent_id) is None:+ _, statuses, _ = await coordinator.graph_snapshot()+ if target_agent_id not in statuses:return json.dumps({"success": False, "error": f"Unknown agent_id: {target_agent_id}"},ensure_ascii=False,diff --git a/strix/tools/finish/tool.py b/strix/tools/finish/tool.pyindex e0207c65..dc6d4564 100644--- a/strix/tools/finish/tool.py+++ b/strix/tools/finish/tool.py@@ -44,24 +44,24 @@ def _do_finish(return {"success": False, "message": "Validation failed", "errors": errors}try:- from strix.telemetry.tracer import get_global_tracer+ from strix.telemetry.scan_store import get_global_scan_store- tracer = get_global_tracer()- if tracer is None:- logger.warning("No global tracer; scan results not persisted")+ scan_store = get_global_scan_store()+ if scan_store is None:+ logger.warning("No global scan store; scan results not persisted")return {"success": True,"scan_completed": True,"message": "Scan completed (not persisted)",- "warning": "Results could not be persisted - tracer unavailable",+ "warning": "Results could not be persisted - scan store unavailable",}- tracer.update_scan_final_fields(+ scan_store.update_scan_final_fields(executive_summary=executive_summary.strip(),methodology=methodology.strip(),technical_analysis=technical_analysis.strip(),recommendations=recommendations.strip(),)- vuln_count = len(tracer.vulnerability_reports)+ vuln_count = len(scan_store.vulnerability_reports)except (ImportError, AttributeError) as e:logger.exception("finish_scan persistence failed")return {"success": False, "message": f"Failed to complete scan: {e!s}"}@@ -98,8 +98,8 @@ async def finish_scan(**Pre-flight checklist (mandatory — do not skip):**1. **Call ``view_agent_graph`` first.** Inspect every entry in the- summary. If ANY agent is in ``running`` / ``waiting`` /- ``llm_failed`` state, you MUST NOT call ``finish_scan`` yet —+ summary. If ANY agent is in ``running`` / ``waiting`` state,+ you MUST NOT call ``finish_scan`` yet —wrap them up first via ``send_message_to_agent`` (ask them tofinish), ``wait_for_message`` (block until their reportarrives), or ``stop_agent`` (graceful cancel). Only ``completed``@@ -178,6 +178,11 @@ async def finish_scan(technical_analysis=technical_analysis,recommendations=recommendations,)- if result.get("success") and result.get("scan_completed"):- inner["finish_scan_called"] = True+ if (+ result.get("success")+ and result.get("scan_completed")+ and coordinator is not None+ and isinstance(me, str)+ ):+ await coordinator.set_status(me, "completed")return json.dumps(result, ensure_ascii=False, default=str)diff --git a/strix/tools/reporting/tool.py b/strix/tools/reporting/tool.pyindex 4b017875..68d9f974 100644--- a/strix/tools/reporting/tool.py+++ b/strix/tools/reporting/tool.py@@ -151,7 +151,7 @@ _REQUIRED_FIELDS = {}-async def _do_create( # noqa: PLR0912+async def _do_create( # noqa: PLR0912, PLR0915*,title: str,description: str,@@ -167,6 +167,8 @@ async def _do_create( # noqa: PLR0912cve: str | None,cwe: str | None,code_locations: list[dict[str, Any]] | None,+ agent_id: str | None = None,+ agent_name: str | None = None,) -> dict[str, Any]:errors: list[str] = []fields = {@@ -212,20 +214,20 @@ async def _do_create( # noqa: PLR0912cvss_score, severity, _vector = _calculate_cvss(cvss_breakdown)try:- from strix.telemetry.tracer import get_global_tracer+ from strix.telemetry.scan_store import get_global_scan_store- tracer = get_global_tracer()- if tracer is None:- logger.warning("No global tracer; vulnerability report not persisted")+ scan_store = get_global_scan_store()+ if scan_store is None:+ logger.warning("No global scan store; vulnerability report not persisted")return {"success": True,"message": f"Vulnerability report '{title}' created (not persisted)",- "warning": "Report could not be persisted - tracer unavailable",+ "warning": "Report could not be persisted - scan store unavailable",}from strix.llm.dedupe import check_duplicate- existing = tracer.get_existing_vulnerabilities()+ existing = scan_store.get_existing_vulnerabilities()candidate = {"title": title,"description": description,@@ -256,7 +258,7 @@ async def _do_create( # noqa: PLR0912"reason": dedupe.get("reason", ""),}- report_id = tracer.add_vulnerability_report(+ report_id = scan_store.add_vulnerability_report(title=title,description=description,severity=severity,@@ -273,6 +275,8 @@ async def _do_create( # noqa: PLR0912cve=cve,cwe=cwe,code_locations=parsed_locations,+ agent_id=agent_id if isinstance(agent_id, str) else None,+ agent_name=agent_name if isinstance(agent_name, str) else None,)except (ImportError, AttributeError) as e:logger.exception("create_vulnerability_report persistence failed")@@ -404,6 +408,17 @@ async def create_vulnerability_report(``fix_before`` (verbatim source), ``fix_after`` (suggestedreplacement)."""+ inner = ctx.context if isinstance(ctx.context, dict) else {}+ raw_agent_id = inner.get("agent_id")+ agent_id = raw_agent_id if isinstance(raw_agent_id, str) else None+ agent_name = None+ coordinator = inner.get("coordinator")+ if agent_id is not None and coordinator is not None:+ names = getattr(coordinator, "names", {})+ if isinstance(names, dict):+ raw_agent_name = names.get(agent_id)+ agent_name = raw_agent_name if isinstance(raw_agent_name, str) else None+result = await _do_create(title=title,description=description,@@ -419,5 +434,7 @@ async def create_vulnerability_report(cve=cve,cwe=cwe,code_locations=code_locations,+ agent_id=agent_id,+ agent_name=agent_name,)return json.dumps(result, ensure_ascii=False, default=str)