chore: bump version to 0.8.3

Models occasionally output text-only narration ("Planning the
assessment...") without a tool call, which halts the interactive agent
loop since the system interprets no-tool-call as "waiting for user
input." Rewrite both interactive and autonomous prompt sections to make
the tool-call requirement absolute with explicit warnings about the
system halt consequence.

.github/workflows/build-release.yml

@@ -16,7 +16,7 @@ jobs:
             target: macos-arm64
           - os: macos-15-intel
             target: macos-x86_64
-          - os: ubuntu-22.04
+          - os: ubuntu-latest
             target: linux-x86_64
           - os: windows-latest
             target: windows-x86_64
@@ -30,15 +30,15 @@ jobs:
         with:
           python-version: '3.12'
 
-      - uses: astral-sh/setup-uv@v5
+      - uses: snok/install-poetry@v1
 
       - name: Build
         shell: bash
         run: |
-          uv sync --frozen
-          uv run pyinstaller strix.spec --noconfirm
+          poetry install --with dev
+          poetry run pyinstaller strix.spec --noconfirm
 
-          VERSION=$(grep '^version' pyproject.toml | head -1 | sed 's/.*"\(.*\)"/\1/')
+          VERSION=$(poetry version -s)
           mkdir -p dist/release
 
           if [[ "${{ runner.os }}" == "Windows" ]]; then

.gitignore

@@ -39,6 +39,18 @@ pip-delete-this-directory.txt
 .pydevproject
 .settings/
 
+# Testing
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+htmlcov/
+
 # FastAPI
 .env.local
 .env.development.local

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ repos:
 
   # MyPy for static type checking
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.17.1
+    rev: v1.16.0
     hooks:
       - id: mypy
         additional_dependencies: [
@@ -19,8 +19,6 @@ repos:
           types-python-dateutil,
           pydantic,
           fastapi,
-          pytest,
-          "openai-agents[litellm]==0.14.6",
         ]
         args: [--install-types, --non-interactive]
 
@@ -33,7 +31,6 @@ repos:
       - id: check-toml
       - id: check-merge-conflict
       - id: check-added-large-files
-        args: ['--maxkb=1024']
       - id: debug-statements
       - id: check-case-conflict
       - id: check-docstring-first
@@ -47,7 +44,7 @@ repos:
 
   # Additional Python code quality checks
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.21.2
+    rev: v3.20.0
     hooks:
       - id: pyupgrade
         args: [--py312-plus]

CONTRIBUTING.md

@@ -8,7 +8,7 @@ Thank you for your interest in contributing to Strix! This guide will help you g
 
 - Python 3.12+
 - Docker (running)
-- [uv](https://docs.astral.sh/uv/) (for dependency management)
+- Poetry (for dependency management)
 - Git
 
 ### Local Development
@@ -24,8 +24,8 @@ Thank you for your interest in contributing to Strix! This guide will help you g
    make setup-dev
 
    # or manually:
-   uv sync
-   uv run pre-commit install
+   poetry install --with=dev
+   poetry run pre-commit install
    ```
 
 3. **Configure your LLM provider**
@@ -36,7 +36,7 @@ Thank you for your interest in contributing to Strix! This guide will help you g
 
 4. **Run Strix in development mode**
    ```bash
-   uv run strix --target https://example.com
+   poetry run strix --target https://example.com
    ```
 
 ## 📚 Contributing Skills

Makefile

@@ -1,4 +1,4 @@
-.PHONY: help install dev-install format lint type-check security check-all clean pre-commit setup-dev dev
+.PHONY: help install dev-install format lint type-check test test-cov clean pre-commit setup-dev
 
 help:
 	@echo "Available commands:"
@@ -8,63 +8,83 @@ help:
 	@echo ""
 	@echo "Code Quality:"
 	@echo "  format        - Format code with ruff"
-	@echo "  lint          - Lint code with ruff"
+	@echo "  lint          - Lint code with ruff and pylint"
 	@echo "  type-check    - Run type checking with mypy and pyright"
 	@echo "  security      - Run security checks with bandit"
 	@echo "  check-all     - Run all code quality checks"
 	@echo ""
+	@echo "Testing:"
+	@echo "  test          - Run tests with pytest"
+	@echo "  test-cov      - Run tests with coverage reporting"
+	@echo ""
 	@echo "Development:"
 	@echo "  pre-commit    - Run pre-commit hooks on all files"
 	@echo "  clean         - Clean up cache files and artifacts"
 
 install:
-	uv sync --no-dev
+	poetry install --only=main
 
 dev-install:
-	uv sync
+	poetry install --with=dev
 
 setup-dev: dev-install
-	uv run pre-commit install
+	poetry run pre-commit install
 	@echo "✅ Development environment setup complete!"
 	@echo "Run 'make check-all' to verify everything works correctly."
 
 format:
 	@echo "🎨 Formatting code with ruff..."
-	uv run ruff format .
+	poetry run ruff format .
 	@echo "✅ Code formatting complete!"
 
 lint:
 	@echo "🔍 Linting code with ruff..."
-	uv run ruff check . --fix
+	poetry run ruff check . --fix
+	@echo "📝 Running additional linting with pylint..."
+	poetry run pylint strix/ --score=no --reports=no
 	@echo "✅ Linting complete!"
 
 type-check:
 	@echo "🔍 Type checking with mypy..."
-	uv run mypy strix/
+	poetry run mypy strix/
 	@echo "🔍 Type checking with pyright..."
-	uv run pyright strix/
+	poetry run pyright strix/
 	@echo "✅ Type checking complete!"
 
 security:
 	@echo "🔒 Running security checks with bandit..."
-	uv run bandit -r strix/ -c pyproject.toml
+	poetry run bandit -r strix/ -c pyproject.toml
 	@echo "✅ Security checks complete!"
 
 check-all: format lint type-check security
 	@echo "✅ All code quality checks passed!"
 
+test:
+	@echo "🧪 Running tests..."
+	poetry run pytest -v
+	@echo "✅ Tests complete!"
+
+test-cov:
+	@echo "🧪 Running tests with coverage..."
+	poetry run pytest -v --cov=strix --cov-report=term-missing --cov-report=html
+	@echo "✅ Tests with coverage complete!"
+	@echo "📊 Coverage report generated in htmlcov/"
+
 pre-commit:
 	@echo "🔧 Running pre-commit hooks..."
-	uv run pre-commit run --all-files
+	poetry run pre-commit run --all-files
 	@echo "✅ Pre-commit hooks complete!"
 
 clean:
 	@echo "🧹 Cleaning up cache files..."
 	find . -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true
+	find . -type d -name ".pytest_cache" -exec rm -rf {} + 2>/dev/null || true
 	find . -type d -name ".mypy_cache" -exec rm -rf {} + 2>/dev/null || true
 	find . -type d -name ".ruff_cache" -exec rm -rf {} + 2>/dev/null || true
+	find . -type d -name "htmlcov" -exec rm -rf {} + 2>/dev/null || true
 	find . -name "*.pyc" -delete 2>/dev/null || true
+	find . -name ".coverage" -delete 2>/dev/null || true
 	@echo "✅ Cleanup complete!"
 
-dev: format lint type-check
+dev: format lint type-check test
 	@echo "✅ Development cycle complete!"

README.md

@@ -8,7 +8,7 @@
 
 # Strix
 
-### The open-source AI pentesting tool. Autonomous AI hackers that find and fix your app’s vulnerabilities.
+### Open-source AI hackers to find and fix your app’s vulnerabilities.
 
 <br/>
 
@@ -28,28 +28,28 @@
 
 
 <a href="https://trendshift.io/repositories/15362" target="_blank"><img src="https://trendshift.io/api/badge/repositories/15362" alt="usestrix/strix | Trendshift" width="250" height="55"/></a>
-<a href="https://trendshift.io/repositories/15362?utm_source=trendshift-badge&amp;utm_medium=badge&amp;utm_campaign=badge-trendshift-15362" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/trendshift/repositories/15362/weekly" alt="usestrix%2Fstrix | Trendshift" width="250" height="55"/></a>
 
 </div>
 
 
+
 > [!TIP]
-> **New!** Strix integrates seamlessly with GitHub Actions and CI/CD pipelines. Automatically scan for vulnerabilities on every pull request and block insecure code before it reaches production - [Get started with no setup required](https://app.strix.ai).
+> **New!** Strix integrates seamlessly with GitHub Actions and CI/CD pipelines. Automatically scan for vulnerabilities on every pull request and block insecure code before it reaches production!
 
 ---
 
 
 ## Strix Overview
 
-Strix are autonomous AI penetration testing agents that act just like real hackers - they run your code dynamically, find vulnerabilities, and validate them through actual proofs-of-concept. Built for developers and security teams who need fast, accurate security testing without the overhead of manual pentesting or the false positives of static analysis tools.
+Strix are autonomous AI agents that act just like real hackers - they run your code dynamically, find vulnerabilities, and validate them through actual proof-of-concepts. Built for developers and security teams who need fast, accurate security testing without the overhead of manual pentesting or the false positives of static analysis tools.
 
 **Key Capabilities:**
 
-- **Full pentesting toolkit** - reconnaissance, exploitation, and validation out of the box
-- **Multi-agent orchestration** - teams of AI pentesters that collaborate and scale
-- **Real exploit validation** - working PoCs, not false positives like legacy vulnerability scanners
-- **Developer‑first CLI** - actionable findings with remediation guidance
-- **Auto‑fix & reporting** - generate patches and compliance-ready pentest reports
+- **Full hacker toolkit** out of the box
+- **Teams of agents** that collaborate and scale
+- **Real validation** with PoCs, not false positives
+- **Developer‑first** CLI with actionable reports
+- **Auto‑fix & reporting** to accelerate remediation
 
 
 <br>
@@ -96,13 +96,13 @@ strix --target ./app-directory
 
 ## ☁️ Strix Platform
 
-Try the Strix full-stack penetration testing platform at **[app.strix.ai](https://app.strix.ai)** - sign up for free, connect your repos and domains, and launch a pentest in minutes.
+Try the Strix full-stack security platform at **[app.strix.ai](https://app.strix.ai)** — sign up for free, connect your repos and domains, and launch a pentest in minutes.
 
-- **Validated findings with PoCs** - every vulnerability includes a working proof-of-concept exploit and reproduction steps
-- **One-click autofix** - AI-generated security patches as ready-to-merge pull requests
-- **Continuous pentesting** - always-on vulnerability scanning that keeps pace with your deployments
-- **DevSecOps integrations** - GitHub, GitLab, Bitbucket, Slack, Jira, Linear, and CI/CD pipelines
-- **Continuous learning** - AI that builds on past findings, adapts to your codebase, and reduces false positives over time
+- **Validated findings with PoCs** and reproduction steps
+- **One-click autofix** as ready-to-merge pull requests
+- **Continuous monitoring** across code, cloud, and infrastructure
+- **Integrations** with GitHub, Slack, Jira, Linear, and CI/CD pipelines
+- **Continuous learning** that builds on past findings and remediations
 
 [**Start your first pentest →**](https://app.strix.ai)
 
@@ -110,38 +110,37 @@ Try the Strix full-stack penetration testing platform at **[app.strix.ai](https:
 
 ## ✨ Features
 
-### Agentic Pentesting Tools
+### Agentic Security Tools
 
-Strix agents come equipped with a comprehensive offensive security toolkit - the same tools used by professional penetration testers and ethical hackers:
+Strix agents come equipped with a comprehensive security testing toolkit:
 
-- **HTTP Interception Proxy** - Full request/response manipulation and analysis with Caido
-- **Browser Exploitation** - Automated browser for testing XSS, CSRF, clickjacking, and auth bypass flows
-- **Shell & Command Execution** - Interactive terminal for exploit development and post-exploitation
-- **Custom Exploit Runtime** - Python sandbox for writing and validating proof-of-concept exploits
-- **Reconnaissance & OSINT** - Automated attack surface mapping, subdomain enumeration, and fingerprinting
-- **Static & Dynamic Code Analysis** - SAST + DAST capabilities for comprehensive application security testing
-- **Vulnerability Knowledge Base** - Structured findings with CVSS scoring and OWASP classification
+- **Full HTTP Proxy** - Full request/response manipulation and analysis
+- **Browser Automation** - Multi-tab browser for testing of XSS, CSRF, auth flows
+- **Terminal Environments** - Interactive shells for command execution and testing
+- **Python Runtime** - Custom exploit development and validation
+- **Reconnaissance** - Automated OSINT and attack surface mapping
+- **Code Analysis** - Static and dynamic analysis capabilities
+- **Knowledge Management** - Structured findings and attack documentation
 
-### Comprehensive Vulnerability Scanner
+### Comprehensive Vulnerability Detection
 
-Strix identifies, validates, and exploits a wide range of security vulnerabilities across the OWASP Top 10 and beyond:
+Strix can identify and validate a wide range of security vulnerabilities:
 
-- **Broken Access Control** - IDOR, privilege escalation, auth bypass
-- **Injection Attacks** - SQL injection, NoSQL injection, OS command injection, SSTI
-- **Server-Side Vulnerabilities** - SSRF, XXE, insecure deserialization, RCE
-- **Client-Side Attacks** - XSS (stored/reflected/DOM), prototype pollution, CSRF
-- **Business Logic Flaws** - Race conditions, payment manipulation, workflow bypass
-- **Authentication & Session** - JWT attacks, session fixation, credential stuffing vectors
-- **Infrastructure & Cloud** - Misconfigurations, exposed services, cloud security issues
-- **API Security** - Broken authentication, mass assignment, rate limiting bypass
+- **Access Control** - IDOR, privilege escalation, auth bypass
+- **Injection Attacks** - SQL, NoSQL, command injection
+- **Server-Side** - SSRF, XXE, deserialization flaws
+- **Client-Side** - XSS, prototype pollution, DOM vulnerabilities
+- **Business Logic** - Race conditions, workflow manipulation
+- **Authentication** - JWT vulnerabilities, session management
+- **Infrastructure** - Misconfigurations, exposed services
 
-### Graph of Agents (Multi-Agent Pentesting)
+### Graph of Agents
 
-Advanced multi-agent orchestration for comprehensive automated penetration testing:
+Advanced multi-agent orchestration for comprehensive security testing:
 
-- **Distributed Pentesting** - Specialized AI agents for recon, exploitation, and post-exploitation
-- **Scalable Security Testing** - Parallel execution across multiple targets for fast, comprehensive coverage
-- **Dynamic Coordination** - Agents share discoveries, chain vulnerabilities, and collaborate like a red team
+- **Distributed Workflows** - Specialized agents for different attacks and assets
+- **Scalable Testing** - Parallel execution for fast comprehensive coverage
+- **Dynamic Coordination** - Agents collaborate and share discoveries
 
 ---
 
@@ -169,25 +168,16 @@ strix --target https://your-app.com --instruction "Perform authenticated testing
 # Multi-target testing (source code + deployed app)
 strix -t https://github.com/org/app -t https://your-app.com
 
-# Targets from a file, one target per non-empty, non-comment line
-strix --target-list ./targets.txt
-
-# White-box source-aware scan (local repository)
-strix --target ./app-directory --scan-mode standard
-
 # Focused testing with custom instructions
 strix --target api.your-app.com --instruction "Focus on business logic flaws and IDOR vulnerabilities"
 
 # Provide detailed instructions through file (e.g., rules of engagement, scope, exclusions)
 strix --target api.your-app.com --instruction-file ./instruction.md
-
-# Force PR diff-scope against a specific base branch
-strix -n --target ./ --scan-mode quick --scope-mode diff --diff-base origin/main
 ```
 
 ### Headless Mode
 
-Run Strix programmatically without interactive UI using the `-n/--non-interactive` flag - perfect for servers and automated jobs. The CLI prints real-time vulnerability findings and the final report before exiting. Exits with non-zero code when vulnerabilities are found.
+Run Strix programmatically without interactive UI using the `-n/--non-interactive` flag—perfect for servers and automated jobs. The CLI prints real-time vulnerability findings, and the final report before exiting. Exits with non-zero code when vulnerabilities are found.
 
 ```bash
 strix -n --target https://your-app.com
@@ -208,8 +198,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
 
       - name: Install Strix
         run: curl -sSL https://strix.ai/install | bash
@@ -222,11 +210,6 @@ jobs:
         run: strix -n -t ./ --scan-mode quick
 ```
 
-> [!TIP]
-> In CI pull request runs, Strix automatically scopes quick reviews to changed files.
-> If diff-scope cannot resolve, ensure checkout uses full history (`fetch-depth: 0`) or pass
-> `--diff-base` explicitly.
-
 ### Configuration
 
 ```bash
@@ -244,19 +227,19 @@ export STRIX_REASONING_EFFORT="high"  # control thinking effort (default: high,
 
 **Recommended models for best results:**
 
-- [OpenAI GPT-5.4](https://openai.com/api/) - `openai/gpt-5.4`
-- [Anthropic Claude Sonnet 4.6](https://claude.com/platform/api) - `anthropic/claude-sonnet-4-6`
-- [Google Gemini 3 Pro Preview](https://cloud.google.com/vertex-ai) - `vertex_ai/gemini-3-pro-preview`
+- [OpenAI GPT-5.4](https://openai.com/api/) — `openai/gpt-5.4`
+- [Anthropic Claude Sonnet 4.6](https://claude.com/platform/api) — `anthropic/claude-sonnet-4-6`
+- [Google Gemini 3 Pro Preview](https://cloud.google.com/vertex-ai) — `vertex_ai/gemini-3-pro-preview`
 
 See the [LLM Providers documentation](https://docs.strix.ai/llm-providers/overview) for all supported providers including Vertex AI, Bedrock, Azure, and local models.
 
-## Enterprise Pentesting
+## Enterprise
 
-Get the same Strix experience with [enterprise-grade](https://strix.ai/demo) controls: SSO (SAML/OIDC), custom compliance-ready penetration testing reports (SOC 2, ISO 27001, PCI DSS), dedicated support & SLA, custom deployment options (VPC/self-hosted), BYOK model support, and tailored AI pentesting agents optimized for your environment. [Learn more](https://strix.ai/demo).
+Get the same Strix experience with [enterprise-grade](https://strix.ai/demo) controls: SSO (SAML/OIDC), custom compliance reports, dedicated support & SLA, custom deployment options (VPC/self-hosted), BYOK model support, and tailored agents optimized for your environment. [Learn more](https://strix.ai/demo).
 
 ## Documentation
 
-Full documentation is available at **[docs.strix.ai](https://docs.strix.ai)** - including detailed guides for usage, CI/CD integrations, skills, and advanced configuration.
+Full documentation is available at **[docs.strix.ai](https://docs.strix.ai)** — including detailed guides for usage, CI/CD integrations, skills, and advanced configuration.
 
 ## Contributing
 

containers/Dockerfile

@@ -12,7 +12,14 @@ RUN useradd -m -s /bin/bash pentester && \
     echo "pentester ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers && \
     touch /home/pentester/.hushlogin
 
-RUN mkdir -p /home/pentester/tools /app/certs && \
+RUN mkdir -p /home/pentester/configs \
+             /home/pentester/wordlists \
+             /home/pentester/output \
+             /home/pentester/scripts \
+             /home/pentester/tools \
+             /app/runtime \
+             /app/tools \
+             /app/certs && \
     chown -R pentester:pentester /app/certs /home/pentester/tools
 
 RUN apt-get update && \
@@ -32,8 +39,11 @@ RUN apt-get update && \
     nodejs npm pipx \
     libcap2-bin \
     gdb \
-    libnss3-tools \
-    chromium fonts-liberation
+    tmux \
+    libnss3 libnspr4 libdbus-1-3 libatk1.0-0 libatk-bridge2.0-0 libcups2 libdrm2 libatspi2.0-0 \
+    libxcomposite1 libxdamage1 libxfixes3 libxrandr2 libgbm1 libxkbcommon0 libpango-1.0-0 libcairo2 libasound2t64 \
+    fonts-unifont fonts-noto-color-emoji fonts-freefont-ttf fonts-dejavu-core ttf-bitstream-vera \
+    libnss3-tools
 
 
 RUN setcap cap_net_raw,cap_net_admin,cap_net_bind_service+eip $(which nmap)
@@ -60,7 +70,11 @@ USER root
 RUN cp /app/certs/ca.crt /usr/local/share/ca-certificates/ca.crt && \
     update-ca-certificates
 
-RUN curl -LsSf https://astral.sh/uv/install.sh | env UV_INSTALL_DIR=/usr/local/bin sh
+RUN curl -sSL https://install.python-poetry.org | POETRY_HOME=/opt/poetry python3 - && \
+    ln -s /opt/poetry/bin/poetry /usr/local/bin/poetry && \
+    chmod +x /usr/local/bin/poetry && \
+    python3 -m venv /app/venv && \
+    chown -R pentester:pentester /app/venv /opt/poetry
 
 USER pentester
 WORKDIR /tmp
@@ -75,7 +89,7 @@ RUN nuclei -update-templates
 
 RUN pipx install arjun && \
     pipx install dirsearch && \
-    pipx inject dirsearch 'setuptools<81' && \
+    pipx inject dirsearch setuptools && \
     pipx install wafw00f
 
 ENV NPM_CONFIG_PREFIX=/home/pentester/.npm-global
@@ -83,43 +97,7 @@ RUN mkdir -p /home/pentester/.npm-global
 
 RUN npm install -g retire@latest && \
     npm install -g eslint@latest && \
-    npm install -g js-beautify@latest && \
-    npm install -g @ast-grep/cli@latest && \
-    npm install -g tree-sitter-cli@latest && \
-    npm install -g agent-browser@0.26.0
-
-ENV AGENT_BROWSER_EXECUTABLE_PATH=/usr/bin/chromium
-ENV AGENT_BROWSER_USER_AGENT="Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
-ENV AGENT_BROWSER_ARGS="--disable-blink-features=AutomationControlled,--no-first-run,--no-default-browser-check,--lang=en-US"
-ENV AGENT_BROWSER_SCREENSHOT_DIR=/workspace/.agent-browser-screenshots
-RUN /home/pentester/.npm-global/bin/agent-browser doctor --offline --quick
-
-RUN set -eux; \
-    TS_PARSER_DIR="/home/pentester/.tree-sitter/parsers"; \
-    mkdir -p "${TS_PARSER_DIR}"; \
-    for repo in tree-sitter-java tree-sitter-javascript tree-sitter-python tree-sitter-go tree-sitter-bash tree-sitter-json tree-sitter-yaml tree-sitter-typescript; do \
-        if [ "$repo" = "tree-sitter-yaml" ]; then \
-            repo_url="https://github.com/tree-sitter-grammars/${repo}.git"; \
-        else \
-            repo_url="https://github.com/tree-sitter/${repo}.git"; \
-        fi; \
-        if [ ! -d "${TS_PARSER_DIR}/${repo}" ]; then \
-            git clone --depth 1 "${repo_url}" "${TS_PARSER_DIR}/${repo}"; \
-        fi; \
-    done; \
-    if [ -d "${TS_PARSER_DIR}/tree-sitter-typescript/typescript" ]; then \
-        ln -sfn "${TS_PARSER_DIR}/tree-sitter-typescript/typescript" "${TS_PARSER_DIR}/tree-sitter-typescript-typescript"; \
-    fi; \
-    if [ -d "${TS_PARSER_DIR}/tree-sitter-typescript/tsx" ]; then \
-        ln -sfn "${TS_PARSER_DIR}/tree-sitter-typescript/tsx" "${TS_PARSER_DIR}/tree-sitter-typescript-tsx"; \
-    fi; \
-    tree-sitter init-config >/dev/null 2>&1 || true; \
-    TS_CONFIG="/home/pentester/.config/tree-sitter/config.json"; \
-    mkdir -p "$(dirname "${TS_CONFIG}")"; \
-    [ -f "${TS_CONFIG}" ] || printf '{}\n' > "${TS_CONFIG}"; \
-    TMP_CFG="$(mktemp)"; \
-    jq --arg p "${TS_PARSER_DIR}" '.["parser-directories"] = ((.["parser-directories"] // []) + [$p] | unique)' "${TS_CONFIG}" > "${TMP_CFG}"; \
-    mv "${TMP_CFG}" "${TS_CONFIG}"
+    npm install -g js-beautify@latest
 
 WORKDIR /home/pentester/tools
 RUN git clone https://github.com/aravind0x7/JS-Snooper.git && \
@@ -132,18 +110,6 @@ RUN git clone https://github.com/aravind0x7/JS-Snooper.git && \
 USER root
 
 RUN curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -b /usr/local/bin
-RUN set -eux; \
-    ARCH="$(uname -m)"; \
-    case "$ARCH" in \
-        x86_64) GITLEAKS_ARCH="x64" ;; \
-        aarch64|arm64) GITLEAKS_ARCH="arm64" ;; \
-        *) echo "Unsupported architecture: $ARCH" >&2; exit 1 ;; \
-    esac; \
-    TAG="$(curl -fsSL https://api.github.com/repos/gitleaks/gitleaks/releases/latest | jq -r .tag_name)"; \
-    curl -fsSL "https://github.com/gitleaks/gitleaks/releases/download/${TAG}/gitleaks_${TAG#v}_linux_${GITLEAKS_ARCH}.tar.gz" -o /tmp/gitleaks.tgz; \
-    tar -xzf /tmp/gitleaks.tgz -C /tmp; \
-    install -m 0755 /tmp/gitleaks /usr/local/bin/gitleaks; \
-    rm -f /tmp/gitleaks /tmp/gitleaks.tgz
 
 RUN apt-get update && apt-get install -y zaproxy
 
@@ -164,12 +130,12 @@ RUN apt-get autoremove -y && \
     apt-get autoclean && \
     rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
 
-ENV PATH="/home/pentester/go/bin:/home/pentester/.local/bin:/home/pentester/.npm-global/bin:/app/.venv/bin:$PATH"
-ENV VIRTUAL_ENV="/app/.venv"
+ENV PATH="/home/pentester/go/bin:/home/pentester/.local/bin:/home/pentester/.npm-global/bin:/app/venv/bin:$PATH"
+ENV VIRTUAL_ENV="/app/venv"
+ENV POETRY_HOME="/opt/poetry"
 
 WORKDIR /app
 
-ARG CAIDO_VERSION=0.56.0
 RUN ARCH=$(uname -m) && \
     if [ "$ARCH" = "x86_64" ]; then \
         CAIDO_ARCH="x86_64"; \
@@ -178,29 +144,36 @@ RUN ARCH=$(uname -m) && \
     else \
         echo "Unsupported architecture: $ARCH" && exit 1; \
     fi && \
-    wget -O caido-cli.tar.gz "https://caido.download/releases/v${CAIDO_VERSION}/caido-cli-v${CAIDO_VERSION}-linux-${CAIDO_ARCH}.tar.gz" && \
+    wget -O caido-cli.tar.gz https://caido.download/releases/v0.48.0/caido-cli-v0.48.0-linux-${CAIDO_ARCH}.tar.gz && \
     tar -xzf caido-cli.tar.gz && \
     chmod +x caido-cli && \
     rm caido-cli.tar.gz && \
     mv caido-cli /usr/local/bin/
 
+ENV STRIX_SANDBOX_MODE=true
+ENV PYTHONPATH=/app
 ENV REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
 ENV SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
 
 RUN mkdir -p /workspace && chown -R pentester:pentester /workspace /app
 
-USER pentester
-RUN python3 -m venv /app/.venv && \
-    /app/.venv/bin/pip install --no-cache-dir caido-sdk-client && \
-    /app/.venv/bin/pip install --no-cache-dir -r /home/pentester/tools/jwt_tool/requirements.txt && \
-    printf '%s\n' \
-        '#!/bin/bash' \
-        'exec /app/.venv/bin/python /home/pentester/tools/jwt_tool/jwt_tool.py "$@"' \
-        > /home/pentester/.local/bin/jwt_tool && \
-    chmod +x /home/pentester/.local/bin/jwt_tool
+COPY pyproject.toml poetry.lock ./
 
-COPY --chown=pentester:pentester strix/tools/proxy/caido_api.py /opt/strix-python/caido_api.py
-ENV PYTHONPATH=/opt/strix-python
+USER pentester
+RUN poetry install --no-root --without dev --extras sandbox
+RUN poetry run playwright install chromium
+
+RUN /app/venv/bin/pip install -r /home/pentester/tools/jwt_tool/requirements.txt && \
+    ln -s /home/pentester/tools/jwt_tool/jwt_tool.py /home/pentester/.local/bin/jwt_tool
+
+RUN echo "# Sandbox Environment" > README.md
+
+COPY strix/__init__.py strix/
+COPY strix/config/ /app/strix/config/
+COPY strix/utils/ /app/strix/utils/
+COPY strix/telemetry/ /app/strix/telemetry/
+COPY strix/runtime/tool_server.py strix/runtime/__init__.py strix/runtime/runtime.py /app/strix/runtime/
+COPY strix/tools/ /app/strix/tools/
 
 RUN echo 'export PATH="/home/pentester/go/bin:/home/pentester/.local/bin:/home/pentester/.npm-global/bin:$PATH"' >> /home/pentester/.bashrc && \
     echo 'export PATH="/home/pentester/go/bin:/home/pentester/.local/bin:/home/pentester/.npm-global/bin:$PATH"' >> /home/pentester/.profile

containers/docker-entrypoint.sh

@@ -9,24 +9,10 @@ if [ ! -f /app/certs/ca.p12 ]; then
   exit 1
 fi
 
-# Caido enforces a Host allowlist (DNS-rebinding protection) and rejects requests
-# whose Host header is a hostname it doesn't recognize. To reach Caido over a
-# hostname (rather than an IP literal), set STRIX_CAIDO_ALLOWED_DOMAINS to a
-# comma-separated list of hostnames to allow. Unset by default.
-# See https://docs.caido.io/app/guides/domain_allowlist
-CAIDO_UI_DOMAIN_ARGS=()
-if [ -n "${STRIX_CAIDO_ALLOWED_DOMAINS:-}" ]; then
-  IFS=',' read -ra _caido_domains <<< "${STRIX_CAIDO_ALLOWED_DOMAINS}"
-  for _d in "${_caido_domains[@]}"; do
-    [ -n "$_d" ] && CAIDO_UI_DOMAIN_ARGS+=(--ui-domain "$_d")
-  done
-fi
-
 caido-cli --listen 0.0.0.0:${CAIDO_PORT} \
           --allow-guests \
           --no-logging \
           --no-open \
-          "${CAIDO_UI_DOMAIN_ARGS[@]}" \
           --import-ca-cert /app/certs/ca.p12 \
           --import-ca-cert-pass "" > "$CAIDO_LOG" 2>&1 &
 
@@ -61,7 +47,68 @@ fi
 
 sleep 2
 
-echo "Caido is up — host bootstraps the guest token + project via the Python SDK."
+echo "Fetching API token..."
+TOKEN=""
+for attempt in 1 2 3 4 5; do
+  RESPONSE=$(curl -sL -X POST \
+    -H "Content-Type: application/json" \
+    -d '{"query":"mutation LoginAsGuest { loginAsGuest { token { accessToken } } }"}' \
+    http://localhost:${CAIDO_PORT}/graphql)
+
+  TOKEN=$(echo "$RESPONSE" | jq -r '.data.loginAsGuest.token.accessToken // empty')
+
+  if [ -n "$TOKEN" ] && [ "$TOKEN" != "null" ]; then
+    echo "Successfully obtained API token (attempt $attempt)."
+    break
+  fi
+
+  echo "Token fetch attempt $attempt failed: $RESPONSE"
+  sleep $((attempt * 2))
+done
+
+if [ -z "$TOKEN" ] || [ "$TOKEN" == "null" ]; then
+  echo "ERROR: Failed to get API token from Caido after 5 attempts."
+  echo "=== Caido log ==="
+  cat "$CAIDO_LOG" 2>/dev/null || echo "(no log available)"
+  exit 1
+fi
+
+export CAIDO_API_TOKEN=$TOKEN
+echo "Caido API token has been set."
+
+echo "Creating a new Caido project..."
+CREATE_PROJECT_RESPONSE=$(curl -sL -X POST \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $TOKEN" \
+  -d '{"query":"mutation CreateProject { createProject(input: {name: \"sandbox\", temporary: true}) { project { id } } }"}' \
+  http://localhost:${CAIDO_PORT}/graphql)
+
+PROJECT_ID=$(echo $CREATE_PROJECT_RESPONSE | jq -r '.data.createProject.project.id')
+
+if [ -z "$PROJECT_ID" ] || [ "$PROJECT_ID" == "null" ]; then
+  echo "Failed to create Caido project."
+  echo "Response: $CREATE_PROJECT_RESPONSE"
+  exit 1
+fi
+
+echo "Caido project created with ID: $PROJECT_ID"
+
+echo "Selecting Caido project..."
+SELECT_RESPONSE=$(curl -sL -X POST \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $TOKEN" \
+  -d '{"query":"mutation SelectProject { selectProject(id: \"'$PROJECT_ID'\") { currentProject { project { id } } } }"}' \
+  http://localhost:${CAIDO_PORT}/graphql)
+
+SELECTED_ID=$(echo $SELECT_RESPONSE | jq -r '.data.selectProject.currentProject.project.id')
+
+if [ "$SELECTED_ID" != "$PROJECT_ID" ]; then
+    echo "Failed to select Caido project."
+    echo "Response: $SELECT_RESPONSE"
+    exit 1
+fi
+
+echo "✅ Caido project selected successfully."
 
 echo "Configuring system-wide proxy settings..."
 
@@ -71,9 +118,9 @@ export https_proxy=http://127.0.0.1:${CAIDO_PORT}
 export HTTP_PROXY=http://127.0.0.1:${CAIDO_PORT}
 export HTTPS_PROXY=http://127.0.0.1:${CAIDO_PORT}
 export ALL_PROXY=http://127.0.0.1:${CAIDO_PORT}
-export NO_PROXY=localhost,127.0.0.1
 export REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
 export SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
+export CAIDO_API_TOKEN=${TOKEN}
 EOF
 
 cat << EOF | sudo tee /etc/environment
@@ -82,7 +129,7 @@ https_proxy=http://127.0.0.1:${CAIDO_PORT}
 HTTP_PROXY=http://127.0.0.1:${CAIDO_PORT}
 HTTPS_PROXY=http://127.0.0.1:${CAIDO_PORT}
 ALL_PROXY=http://127.0.0.1:${CAIDO_PORT}
-NO_PROXY=localhost,127.0.0.1
+CAIDO_API_TOKEN=${TOKEN}
 EOF
 
 cat << EOF | sudo tee /etc/wgetrc
@@ -104,7 +151,34 @@ sudo -u pentester certutil -N -d sql:/home/pentester/.pki/nssdb --empty-password
 sudo -u pentester certutil -A -n "Testing Root CA" -t "C,," -i /app/certs/ca.crt -d sql:/home/pentester/.pki/nssdb
 echo "✅ CA added to browser trust store"
 
-mkdir -p /workspace/.agent-browser-screenshots
+echo "Starting tool server..."
+cd /app
+export PYTHONPATH=/app
+export STRIX_SANDBOX_MODE=true
+export POETRY_VIRTUALENVS_CREATE=false
+export TOOL_SERVER_TIMEOUT="${STRIX_SANDBOX_EXECUTION_TIMEOUT:-120}"
+TOOL_SERVER_LOG="/tmp/tool_server.log"
+
+sudo -E -u pentester \
+  poetry run python -m strix.runtime.tool_server \
+  --token="$TOOL_SERVER_TOKEN" \
+  --host=0.0.0.0 \
+  --port="$TOOL_SERVER_PORT" \
+  --timeout="$TOOL_SERVER_TIMEOUT" > "$TOOL_SERVER_LOG" 2>&1 &
+
+for i in {1..10}; do
+  if curl -s "http://127.0.0.1:$TOOL_SERVER_PORT/health" | grep -q '"status":"healthy"'; then
+    echo "✅ Tool server healthy on port $TOOL_SERVER_PORT"
+    break
+  fi
+  if [ $i -eq 10 ]; then
+    echo "ERROR: Tool server failed to become healthy"
+    echo "=== Tool server log ==="
+    cat "$TOOL_SERVER_LOG" 2>/dev/null || echo "(no log)"
+    exit 1
+  fi
+  sleep 1
+done
 
 echo "✅ Container ready"
 

docs/advanced/configuration.mdx

@@ -41,8 +41,20 @@ Configure Strix using environment variables or a config file.
   API key for Perplexity AI. Enables real-time web search during scans for OSINT and vulnerability research.
 </ParamField>
 
+<ParamField path="STRIX_DISABLE_BROWSER" default="false" type="boolean">
+  Disable browser automation tools.
+</ParamField>
+
 <ParamField path="STRIX_TELEMETRY" default="1" type="string">
-  Telemetry toggle. Set to `0`, `false`, `no`, or `off` to disable telemetry (PostHog, Scarf, OTEL).
+  Global telemetry default toggle. Set to `0`, `false`, `no`, or `off` to disable both PostHog and OTEL unless overridden by per-channel flags below.
+</ParamField>
+
+<ParamField path="STRIX_OTEL_TELEMETRY" type="string">
+  Enable/disable OpenTelemetry run observability independently. When unset, falls back to `STRIX_TELEMETRY`.
+</ParamField>
+
+<ParamField path="STRIX_POSTHOG_TELEMETRY" type="string">
+  Enable/disable PostHog product telemetry independently. When unset, falls back to `STRIX_TELEMETRY`.
 </ParamField>
 
 <ParamField path="TRACELOOP_BASE_URL" type="string">
@@ -67,7 +79,7 @@ When remote vars are set, Strix dual-writes telemetry to both local JSONL and th
 
 ## Docker Configuration
 
-<ParamField path="STRIX_IMAGE" default="ghcr.io/usestrix/strix-sandbox:1.0.0" type="string">
+<ParamField path="STRIX_IMAGE" default="ghcr.io/usestrix/strix-sandbox:0.1.13" type="string">
   Docker image to use for the sandbox container.
 </ParamField>
 
@@ -79,10 +91,6 @@ When remote vars are set, Strix dual-writes telemetry to both local JSONL and th
   Runtime backend for the sandbox environment.
 </ParamField>
 
-<ParamField path="STRIX_MAX_LOCAL_COPY_MB" default="1024" type="integer">
-  Maximum size (in MB) of a local directory target that Strix will copy into the sandbox file-by-file. Larger targets exit early with a suggestion to use `--mount` instead. Set to `0` to disable the check.
-</ParamField>
-
 ## Sandbox Configuration
 
 <ParamField path="STRIX_SANDBOX_EXECUTION_TIMEOUT" default="120" type="integer">

docs/contributing.mdx

@@ -9,7 +9,7 @@ description: "Contribute to Strix development"
 
 - Python 3.12+
 - Docker (running)
-- [uv](https://docs.astral.sh/uv/)
+- Poetry
 - Git
 
 ### Local Development
@@ -26,8 +26,8 @@ description: "Contribute to Strix development"
     make setup-dev
 
     # or manually:
-    uv sync
-    uv run pre-commit install
+    poetry install --with=dev
+    poetry run pre-commit install
     ```
   </Step>
   <Step title="Configure LLM">
@@ -38,7 +38,7 @@ description: "Contribute to Strix development"
   </Step>
   <Step title="Run Strix">
     ```bash
-    uv run strix --target https://example.com
+    poetry run strix --target https://example.com
     ```
   </Step>
 </Steps>

docs/docs.json

@@ -38,7 +38,6 @@
               "llm-providers/vertex",
               "llm-providers/bedrock",
               "llm-providers/azure",
-              "llm-providers/novita",
               "llm-providers/local"
             ]
           },

docs/integrations/ci-cd.mdx

@@ -13,12 +13,6 @@ Use the `-n` or `--non-interactive` flag:
 strix -n --target ./app --scan-mode quick
 ```
 
-For pull-request style CI runs, Strix automatically scopes quick scans to changed files. You can force this behavior and set a base ref explicitly:
-
-```bash
-strix -n --target ./app --scan-mode quick --scope-mode diff --diff-base origin/main
-```
-
 ## Exit Codes
 
 | Code | Meaning |
@@ -84,7 +78,3 @@ jobs:
 <Note>
 All CI platforms require Docker access. Ensure your runner has Docker available.
 </Note>
-
-<Tip>
-If diff-scope fails in CI, fetch full git history (for example, `fetch-depth: 0` in GitHub Actions) so merge-base and branch comparison can be resolved.
-</Tip>

docs/integrations/github-actions.mdx

@@ -18,8 +18,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
 
       - name: Install Strix
         run: curl -sSL https://strix.ai/install | bash
@@ -60,7 +58,3 @@ The workflow fails when vulnerabilities are found:
 <Tip>
 Use `quick` mode for PRs to keep feedback fast. Schedule `deep` scans nightly.
 </Tip>
-
-<Note>
-For pull_request workflows, Strix automatically uses changed-files diff-scope in CI/headless runs. If diff resolution fails, ensure full history is fetched (`fetch-depth: 0`) or set `--diff-base`.
-</Note>

docs/llm-providers/bedrock.mdx

@@ -3,14 +3,6 @@ title: "AWS Bedrock"
 description: "Configure Strix with models via AWS Bedrock"
 ---
 
-## Installation
-
-Bedrock requires the AWS SDK dependency. Install Strix with the bedrock extra:
-
-```bash
-pipx install "strix-agent[bedrock]"
-```
-
 ## Setup
 
 ```bash

docs/llm-providers/novita.mdx

@@ -1,35 +0,0 @@
----
-title: "Novita AI"
-description: "Configure Strix with Novita AI models"
----
-
-[Novita AI](https://novita.ai) provides fast, cost-efficient inference for open-source models via an OpenAI-compatible API.
-
-## Setup
-
-```bash
-export STRIX_LLM="openai/moonshotai/kimi-k2.5"
-export LLM_API_KEY="your-novita-api-key"
-export LLM_API_BASE="https://api.novita.ai/openai"
-```
-
-## Available Models
-
-| Model | Configuration |
-|-------|---------------|
-| Kimi K2.5 | `openai/moonshotai/kimi-k2.5` |
-| GLM-5 | `openai/zai-org/glm-5` |
-| MiniMax M2.5 | `openai/minimax/minimax-m2.5` |
-
-## Get API Key
-
-1. Sign up at [novita.ai](https://novita.ai)
-2. Navigate to **API Keys** in your dashboard
-3. Create a new key and copy it
-
-## Benefits
-
-- **Cost-efficient** — Competitive pricing with per-token billing
-- **OpenAI-compatible** — Drop-in replacement using `LLM_API_BASE`
-- **Large context** — Models support up to 262k token context windows
-- **Function calling** — All listed models support tool/function calling

docs/quickstart.mdx

@@ -62,9 +62,6 @@ strix --target https://your-app.com
 
 # Multiple targets (white-box testing)
 strix -t https://github.com/org/repo -t https://your-app.com
-
-# Targets from a file, one target per non-empty, non-comment line
-strix --target-list ./targets.txt
 ```
 
 ## Next Steps

docs/tools/proxy.mdx

@@ -30,33 +30,23 @@ The agent can take any captured request and replay it with modifications:
 
 ## Python Integration
 
-Proxy helpers are available to sandbox Python scripts through the image-baked `caido_api` module. This enables powerful scripted security testing:
+All proxy functions are automatically available in Python sessions. This enables powerful scripted security testing:
 
 ```python
-import asyncio
+# List recent POST requests
+post_requests = list_requests(
+    httpql_filter='req.method.eq:"POST"',
+    page_size=20
+)
 
-from caido_api import list_requests, repeat_request, view_request
+# View a specific request
+request_details = view_request("req_123", part="request")
 
-
-async def main():
-    # List recent POST requests
-    post_requests = await list_requests(
-        httpql_filter='req.method.eq:"POST"',
-        first=20,
-    )
-
-    # View a specific request
-    request_details = await view_request("req_123", part="request")
-
-    # Replay with modified payload
-    response = await repeat_request(
-        "req_123",
-        modifications={"body": '{"user_id": "admin"}'},
-    )
-    print(response["status"], request_details is not None, len(post_requests.edges))
-
-
-asyncio.run(main())
+# Replay with modified payload
+response = repeat_request("req_123", {
+    "body": '{"user_id": "admin"}'
+})
+print(f"Status: {response['status_code']}")
 ```
 
 ### Available Functions
@@ -66,42 +56,28 @@ asyncio.run(main())
 | `list_requests()`      | Query captured traffic with HTTPQL filters |
 | `view_request()`       | Get full request/response details          |
 | `repeat_request()`     | Replay a request with modifications        |
-| `list_sitemap()`       | Browse the request-tree view of discovered surface |
-| `view_sitemap_entry()` | Inspect one sitemap entry + its related requests |
+| `send_request()`       | Send a new HTTP request                    |
 | `scope_rules()`        | Manage proxy scope (allowlist/denylist)    |
-
-For one-off arbitrary requests, use shell tooling like `curl` — the
-sandbox's `HTTP_PROXY` env routes the traffic through Caido
-automatically, so it lands in `list_requests` and can be replayed via
-`repeat_request`.
+| `list_sitemap()`       | View discovered endpoints                  |
+| `view_sitemap_entry()` | Get details for a sitemap entry            |
 
 ### Example: Automated IDOR Testing
 
 ```python
-import asyncio
-
 # Get all requests to user endpoints
-from caido_api import list_requests, repeat_request
+user_requests = list_requests(
+    httpql_filter='req.path.cont:"/users/"'
+)
 
+for req in user_requests.get('requests', []):
+    # Try accessing with different user IDs
+    for test_id in ['1', '2', 'admin', '../admin']:
+        response = repeat_request(req['id'], {
+            'url': req['path'].replace('/users/1', f'/users/{test_id}')
+        })
 
-async def main():
-    user_requests = await list_requests(httpql_filter='req.path.cont:"/users/"')
-
-    for edge in user_requests.edges:
-        req = edge.node.request
-        scheme = "https" if req.is_tls else "http"
-        for test_id in ["1", "2", "admin", "../admin"]:
-            url = f"{scheme}://{req.host}{req.path.replace('/users/1', f'/users/{test_id}')}"
-            response = await repeat_request(
-                req.id,
-                modifications={"url": url},
-            )
-            print(req.id, test_id, response["status"])
-            if response["status"] == "DONE":
-                print(f"Replay completed for candidate {test_id}")
-
-
-asyncio.run(main())
+        if response['status_code'] == 200:
+            print(f"Potential IDOR: {test_id} returned 200")
 ```
 
 ## Human-in-the-Loop

docs/tools/sandbox.mdx

@@ -45,21 +45,13 @@ Strix runs inside a Kali Linux-based Docker container with a comprehensive set o
 | [js-beautify](https://github.com/beautifier/js-beautify) | JavaScript deobfuscation       |
 | [JSHint](https://jshint.com)                             | JavaScript code quality tool   |
 
-## Source-Aware Analysis
-
-| Tool                                                    | Description                                   |
-| ------------------------------------------------------- | --------------------------------------------- |
-| [Semgrep](https://github.com/semgrep/semgrep)          | Fast SAST and custom rule matching            |
-| [ast-grep](https://ast-grep.github.io)                 | Structural AST/CST-aware code search (`sg`)   |
-| [Tree-sitter](https://tree-sitter.github.io/tree-sitter/) | Syntax tree parsing and symbol extraction (Java/JS/TS/Python/Go/Bash/JSON/YAML grammars pre-configured) |
-| [Bandit](https://bandit.readthedocs.io)                | Python security linter                        |
-
 ## Secret Detection
 
 | Tool                                                        | Description                           |
 | ----------------------------------------------------------- | ------------------------------------- |
 | [TruffleHog](https://github.com/trufflesecurity/trufflehog) | Find secrets in code and history      |
-| [Gitleaks](https://github.com/gitleaks/gitleaks)            | Detect hardcoded secrets in repositories |
+| [Semgrep](https://github.com/semgrep/semgrep)               | Static analysis for security patterns |
+| [Bandit](https://bandit.readthedocs.io)                     | Python security linter                |
 
 ## Authentication Testing
 
@@ -72,7 +64,7 @@ Strix runs inside a Kali Linux-based Docker container with a comprehensive set o
 
 | Tool                       | Description                                    |
 | -------------------------- | ---------------------------------------------- |
-| [Trivy](https://trivy.dev) | Filesystem/container scanning for vulns, misconfigurations, secrets, and licenses |
+| [Trivy](https://trivy.dev) | Container and dependency vulnerability scanner |
 
 ## HTTP Proxy
 

docs/tools/terminal.mdx

@@ -32,18 +32,14 @@ sqlmap -u "https://example.com/page?id=1"
 ### Code Analysis
 
 ```bash
-# Fast SAST triage
-semgrep --config auto ./src
-
-# Structural AST search
-sg scan ./src
-
-# Secret detection
-gitleaks detect --source ./
+# Search for secrets
 trufflehog filesystem ./
 
-# Supply-chain and misconfiguration checks
-trivy fs ./
+# Static analysis
+semgrep --config auto ./src
+
+# Grep for patterns
+grep -r "password" ./
 ```
 
 ### Custom Scripts

docs/usage/cli.mdx

@@ -6,31 +6,13 @@ description: "Command-line options for Strix"
 ## Basic Usage
 
 ```bash
-strix (--target <target> | --target-list <path> | --mount <path>) [options]
+strix --target <target> [options]
 ```
 
 ## Options
 
-<ParamField path="--target, -t" type="string">
-  Target to test. Accepts URLs, repositories, local directories, domains, or IP addresses. Can be specified multiple times. Fresh runs require at least one target source: `--target`, `--target-list`, or `--mount`.
-</ParamField>
-
-<ParamField path="--target-list" type="string">
-  Path to a file containing targets, one per non-empty, non-comment line. Lines starting with `#` are ignored. Can be specified multiple times and combined with `--target`.
-</ParamField>
-
-<ParamField path="--mount" type="string">
-  Bind-mount a local directory into the sandbox (read-only) instead of copying it in file-by-file. Use this for large repositories that are too big to stream into the container. Can be specified multiple times.
-
-  Strix copies local `--target` directories into the sandbox one file at a time, which stalls on very large trees. When a local target exceeds the copy limit (see `STRIX_MAX_LOCAL_COPY_MB`, default 1024 MB) Strix exits early and asks you to re-run with `--mount`.
-
-  <Note>
-    The mount is read-only to protect your source from accidental modification. This is not a hard security boundary: a root process inside the container can remount it writable, so treat `--mount` as "scan my own code", not as isolation from untrusted code.
-  </Note>
-
-  <Note>
-    The size pre-flight only covers local directory targets. Remote repositories (cloned at scan time) are not size-checked.
-  </Note>
+<ParamField path="--target, -t" type="string" required>
+  Target to test. Accepts URLs, repositories, local directories, domains, or IP addresses. Can be specified multiple times.
 </ParamField>
 
 <ParamField path="--instruction" type="string">
@@ -45,14 +27,6 @@ strix (--target <target> | --target-list <path> | --mount <path>) [options]
   Scan depth: `quick`, `standard`, or `deep`.
 </ParamField>
 
-<ParamField path="--scope-mode" type="string" default="auto">
-  Code scope mode: `auto` (enable PR diff-scope in CI/headless runs), `diff` (force changed-files scope), or `full` (disable diff-scope).
-</ParamField>
-
-<ParamField path="--diff-base" type="string">
-  Target branch or commit to compare against (e.g., `origin/main`). Defaults to the repository's default branch.
-</ParamField>
-
 <ParamField path="--non-interactive, -n" type="boolean">
   Run in headless mode without TUI. Ideal for CI/CD.
 </ParamField>
@@ -61,29 +35,6 @@ strix (--target <target> | --target-list <path> | --mount <path>) [options]
   Path to a custom config file (JSON) to use instead of `~/.strix/cli-config.json`.
 </ParamField>
 
-<ParamField path="--max-budget-usd" type="number">
-  Maximum LLM spend in USD for the whole scan, counted cumulatively across the
-  root agent and every child agent. The budget is checked after each model
-  response; once the running cost reaches the threshold, the scan stops cleanly
-  with a `stopped` status (not a failure) and the sandbox is torn down.
-
-  Must be greater than `0`. Omit the flag for no limit.
-
-  **Limitations**
-
-  - The check fires *after* a response is returned, so the final spend can
-    slightly overshoot the limit by any calls already in flight when the
-    threshold is crossed (most relevant with several child agents running
-    concurrently).
-  - Cost is a best-effort estimate derived from token usage and model pricing;
-    providers that do not expose priced usage may under-count.
-  - For LiteLLM-routed models, Strix enables streaming success callbacks to
-    capture provider-reported cost. Message content remains excluded, but
-    third-party LiteLLM callbacks configured in the same process can receive
-    other streaming metadata such as model names, request IDs, and token
-    counts.
-</ParamField>
-
 ## Examples
 
 ```bash
@@ -99,17 +50,8 @@ strix --target api.example.com --instruction "Focus on IDOR and auth bypass"
 # CI/CD mode
 strix -n --target ./ --scan-mode quick
 
-# Force diff-scope against a specific base ref
-strix -n --target ./ --scan-mode quick --scope-mode diff --diff-base origin/main
-
 # Multi-target white-box testing
 strix -t https://github.com/org/app -t https://staging.example.com
-
-# Targets from a file
-strix --target-list ./targets.txt
-
-# Large local repository — bind-mount instead of copying it in
-strix --mount ./huge-monorepo
 ```
 
 ## Exit Codes

docs/usage/scan-modes.mdx

@@ -31,8 +31,6 @@ Balanced testing for routine security reviews. Best for:
 
 **Duration**: 30 minutes to 1 hour
 
-**White-box behavior**: Uses source-aware mapping and static triage to prioritize dynamic exploit validation paths.
-
 ## Deep
 
 ```bash
@@ -46,8 +44,6 @@ Thorough penetration testing. Best for:
 
 **Duration**: 1-4 hours depending on target complexity
 
-**White-box behavior**: Runs broad source-aware triage (`semgrep`, AST structural search, secrets, supply-chain checks) and then systematically validates top candidates dynamically.
-
 <Note>
 Deep mode is the default. It explores edge cases, chained vulnerabilities, and complex attack paths.
 </Note>

pyproject.toml

@@ -1,13 +1,10 @@
-[project]
+[tool.poetry]
 name = "strix-agent"
-version = "1.0.4"
+version = "0.8.3"
 description = "Open-source AI Hackers for your apps"
+authors = ["Strix <hi@usestrix.com>"]
 readme = "README.md"
 license = "Apache-2.0"
-requires-python = ">=3.12"
-authors = [
-  { name = "Strix", email = "hi@usestrix.com" },
-]
 keywords = [
   "cybersecurity",
   "security",
@@ -32,46 +29,81 @@ classifiers = [
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
 ]
-dependencies = [
-  "openai-agents[litellm]==0.14.6",
-  "pydantic>=2.11.3",
-  "pydantic-settings>=2.13.0",
-  "rich",
-  "docker>=7.1.0",
-  "textual>=6.0.0",
-  "requests>=2.32.0",
-  "cvss>=3.2",
-  "caido-sdk-client>=0.2.0",
+packages = [
+  { include = "strix", format = ["sdist", "wheel"] }
+]
+include = [
+  "LICENSE",
+  "README.md",
+  "strix/agents/**/*.jinja",
+  "strix/skills/**/*.md",
+  "strix/**/*.xml",
+  "strix/**/*.tcss"
 ]
 
-[project.optional-dependencies]
-vertex = ["google-auth>=2.0.0"]
-bedrock = ["boto3>=1.28.0"]
-
-[project.scripts]
+[tool.poetry.scripts]
 strix = "strix.interface.main:main"
 
-[dependency-groups]
-dev = [
-  "mypy>=1.16.0",
-  "ruff>=0.11.13",
-  "pyright>=1.1.401",
-  "bandit>=1.8.3",
-  "pre-commit>=4.2.0",
-  "pyinstaller>=6.17.0; python_version >= '3.12' and python_version < '3.15'",
-  "pytest>=8.3",
-  "pytest-asyncio>=0.24",
-]
+[tool.poetry.dependencies]
+python = "^3.12"
+# Core CLI dependencies
+litellm = { version = "~1.81.1", extras = ["proxy"] }
+tenacity = "^9.0.0"
+pydantic = {extras = ["email"], version = "^2.11.3"}
+rich = "*"
+docker = "^7.1.0"
+textual = "^4.0.0"
+xmltodict = "^0.13.0"
+requests = "^2.32.0"
+cvss = "^3.2"
+traceloop-sdk = "^0.53.0"
+opentelemetry-exporter-otlp-proto-http = "^1.40.0"
+scrubadub = "^2.0.1"
 
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
+# Optional LLM provider dependencies
+google-cloud-aiplatform = { version = ">=1.38", optional = true }
+
+# Sandbox-only dependencies (only needed inside Docker container)
+fastapi = { version = "*", optional = true }
+uvicorn = { version = "*", optional = true }
+ipython = { version = "^9.3.0", optional = true }
+openhands-aci = { version = "^0.3.0", optional = true }
+playwright = { version = "^1.48.0", optional = true }
+gql = { version = "^3.5.3", extras = ["requests"], optional = true }
+pyte = { version = "^0.8.1", optional = true }
+libtmux = { version = "^0.46.2", optional = true }
+numpydoc = { version = "^1.8.0", optional = true }
+defusedxml = "^0.7.1"
+
+[tool.poetry.extras]
+vertex = ["google-cloud-aiplatform"]
+sandbox = ["fastapi", "uvicorn", "ipython", "openhands-aci", "playwright", "gql", "pyte", "libtmux", "numpydoc"]
+
+[tool.poetry.group.dev.dependencies]
+# Type checking and static analysis
+mypy = "^1.16.0"
+ruff = "^0.11.13"
+pyright = "^1.1.401"
+pylint = "^3.3.7"
+bandit = "^1.8.3"
+
+# Testing
+pytest = "^8.4.0"
+pytest-asyncio = "^1.0.0"
+pytest-cov = "^6.1.1"
+pytest-mock = "^3.14.1"
+
+# Development tools
+pre-commit = "^4.2.0"
+black = "^25.1.0"
+isort = "^6.0.1"
+
+# Build tools
+pyinstaller = { version = "^6.17.0", python = ">=3.12,<3.15" }
 
 [build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["strix"]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
 
 # ============================================================================
 # Type Checking Configuration
@@ -102,20 +134,34 @@ pretty = true
 [[tool.mypy.overrides]]
 module = [
     "litellm.*",
+    "tenacity.*",
+    "numpydoc.*",
     "rich.*",
+    "IPython.*",
+    "openhands_aci.*",
+    "playwright.*",
+    "uvicorn.*",
     "jinja2.*",
-    "textual.*",
-    "cvss.*",
-    "docker.*",
-    "caido_sdk_client.*",
     "pydantic_settings.*",
+    "jwt.*",
+    "httpx.*",
+    "gql.*",
+    "textual.*",
+    "pyte.*",
+    "libtmux.*",
+    "pytest.*",
+    "cvss.*",
+    "opentelemetry.*",
+    "scrubadub.*",
+    "traceloop.*",
 ]
 ignore_missing_imports = true
-disable_error_code = ["import-untyped"]
 
+# Relax strict rules for test files (pytest decorators are not fully typed)
 [[tool.mypy.overrides]]
 module = ["tests.*"]
 disallow_untyped_decorators = false
+disallow_untyped_defs = false
 
 # ============================================================================
 # Ruff Configuration (Fast Python Linter & Formatter)
@@ -127,6 +173,7 @@ line-length = 100
 extend-exclude = [
     ".git",
     ".mypy_cache",
+    ".pytest_cache",
     ".ruff_cache",
     "__pycache__",
     "build",
@@ -162,6 +209,7 @@ select = [
     "PIE", # flake8-pie
     "T20", # flake8-print
     "PYI", # flake8-pyi
+    "PT",  # flake8-pytest-style
     "Q",   # flake8-quotes
     "RSE", # flake8-raise
     "RET", # flake8-return
@@ -199,56 +247,21 @@ ignore = [
 ]
 
 [tool.ruff.lint.per-file-ignores]
-# Lazy imports inside functions to avoid circular dependency with
-# strix.telemetry / strix.report.dedupe / cvss.
-"strix/tools/notes/tools.py" = ["PLC0415", "TC002"]
-"strix/tools/finish/tool.py" = ["PLC0415", "TC002"]
-"strix/tools/reporting/tool.py" = ["PLC0415", "TC002"]
+"tests/**/*.py" = [
+    "S106",   # Possible hardcoded password
+    "S108",   # Possible insecure usage of temporary file/directory
+    "ARG001", # Unused function argument
+    "PLR2004", # Magic value used in comparison
+]
 "strix/tools/**/*.py" = [
     "ARG001", # Unused function argument (tools may have unused args for interface consistency)
 ]
-# Custom Docker subclass duplicates parent body; some imports are for annotations.
-# 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"]
-"strix/runtime/docker_client.py" = [
-    "TC002",  # Manifest, Container imported for annotations
-    "TC003",  # uuid imported for annotation
-]
-# SDK function-tool wrappers: the SDK calls get_type_hints() at registration
-# time to derive the JSON schema, which evaluates annotations at runtime —
-# so RunContextWrapper / Tool / TResponseInputItem must be imported eagerly,
-# not under TYPE_CHECKING.
-"strix/tools/todo/tools.py" = ["TC002"]
-"strix/tools/thinking/tool.py" = ["TC002"]
-"strix/tools/web_search/tool.py" = ["TC002"]
-"strix/tools/proxy/tools.py" = ["TC002", "PLR0911"]
-"strix/tools/agents_graph/tools.py" = ["TC002"]
-"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.
-"strix/core/runner.py" = ["TC003", "PLR0912", "PLR0915", "PLC0415"]
-# ReportState carries scan artifact/report fields and
-# a runtime ``Callable`` annotation on ``vulnerability_found_callback``.
-"strix/report/state.py" = ["TC003", "PLR0912", "PLR0915", "E501", "PERF401"]
-"strix/report/usage.py" = ["PLC0415"]
-"strix/config/models.py" = ["PLC0415"]
-# 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"]
-# CLI / TUI / main keep extensive lazy imports + broad exception
-# swallows for resilience around terminal-rendering errors.
-"strix/interface/cli.py" = ["BLE001", "PLC0415"]
-"strix/interface/tui/app.py" = ["BLE001", "PLC0415", "PLR0912", "PLR0915", "SIM105"]
-"strix/interface/main.py" = ["BLE001", "PLC0415", "PLR0912", "PLR0915"]
-"strix/interface/tui/renderers/agent_message_renderer.py" = ["PLC0415"]
 
 [tool.ruff.lint.isort]
 force-single-line = false
 lines-after-imports = 2
 known-first-party = ["strix"]
-known-third-party = ["pydantic"]
+known-third-party = ["fastapi", "pydantic"]
 
 [tool.ruff.lint.pylint]
 max-args = 8
@@ -324,13 +337,55 @@ force_grid_wrap = 0
 use_parentheses = true
 ensure_newline_before_comments = true
 known_first_party = ["strix"]
-known_third_party = ["pydantic", "litellm"]
+known_third_party = ["fastapi", "pydantic", "litellm", "tenacity"]
+
+# ============================================================================
+# Pytest Configuration
+# ============================================================================
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = [
+    "--strict-markers",
+    "--strict-config",
+    "--cov=strix",
+    "--cov-report=term-missing",
+    "--cov-report=html",
+    "--cov-report=xml",
+]
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]
+python_functions = ["test_*"]
+python_classes = ["Test*"]
+asyncio_mode = "auto"
+
+[tool.coverage.run]
+source = ["strix"]
+omit = [
+    "*/tests/*",
+    "*/migrations/*",
+    "*/__pycache__/*"
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "if self.debug:",
+    "if settings.DEBUG",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if 0:",
+    "if __name__ == .__main__.:",
+    "class .*\\bProtocol\\):",
+    "@(abc\\.)?abstractmethod",
+]
 
 # ============================================================================
 # Bandit Configuration (Security Linting)
 # ============================================================================
 
 [tool.bandit]
-exclude_dirs = ["docs", "build", "dist"]
+exclude_dirs = ["tests", "docs", "build", "dist"]
 skips = ["B101", "B601", "B404", "B603", "B607"]  # Skip assert, shell injection, subprocess import and partial path checks
 severity = "medium"

scripts/build.sh

@@ -33,23 +33,23 @@ echo -e "${YELLOW}Platform:${NC} $OS_NAME-$ARCH_NAME"
 
 cd "$PROJECT_ROOT"
 
-if ! command -v uv &> /dev/null; then
-    echo -e "${RED}Error: uv is not installed${NC}"
-    echo "Please install uv first: https://docs.astral.sh/uv/getting-started/installation/"
+if ! command -v poetry &> /dev/null; then
+    echo -e "${RED}Error: Poetry is not installed${NC}"
+    echo "Please install Poetry first: https://python-poetry.org/docs/#installation"
     exit 1
 fi
 
 echo -e "\n${BLUE}Installing dependencies...${NC}"
-uv sync --frozen
+poetry install --with dev
 
-VERSION=$(grep '^version' pyproject.toml | head -1 | sed 's/.*"\(.*\)"/\1/')
+VERSION=$(poetry version -s)
 echo -e "${YELLOW}Version:${NC} $VERSION"
 
 echo -e "\n${BLUE}Cleaning previous builds...${NC}"
 rm -rf build/ dist/
 
 echo -e "\n${BLUE}Building binary with PyInstaller...${NC}"
-uv run pyinstaller strix.spec --noconfirm
+poetry run pyinstaller strix.spec --noconfirm
 
 RELEASE_DIR="dist/release"
 mkdir -p "$RELEASE_DIR"

scripts/docker.sh

@@ -1,16 +0,0 @@
-#!/bin/bash
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-
-IMAGE="strix-sandbox"
-TAG="${1:-dev}"
-
-echo "Building $IMAGE:$TAG ..."
-docker build \
-  -f "$PROJECT_ROOT/containers/Dockerfile" \
-  -t "$IMAGE:$TAG" \
-  "$PROJECT_ROOT"
-
-echo "Done: $IMAGE:$TAG"

scripts/install.sh

@@ -4,7 +4,7 @@ set -euo pipefail
 
 APP=strix
 REPO="usestrix/strix"
-STRIX_IMAGE="ghcr.io/usestrix/strix-sandbox:1.0.0"
+STRIX_IMAGE="ghcr.io/usestrix/strix-sandbox:0.1.13"
 
 MUTED='\033[0;2m'
 RED='\033[0;31m'

strix.spec

@@ -32,8 +32,6 @@ datas += collect_data_files('tiktoken_ext')
 
 datas += collect_data_files('litellm')
 
-datas += collect_data_files('agents', includes=['**/*.md', '**/*.jinja', '**/*.json'])
-
 hiddenimports = [
     # Core dependencies
     'litellm',
@@ -118,58 +116,26 @@ hiddenimports = [
     'strix.interface.main',
     'strix.interface.cli',
     'strix.interface.tui',
-    'strix.interface.tui.app',
-    'strix.interface.tui.history',
-    'strix.interface.tui.live_view',
-    'strix.interface.tui.messages',
-    'strix.interface.tui.renderers',
-    'strix.interface.tui.renderers.agent_message_renderer',
-    'strix.interface.tui.renderers.agents_graph_renderer',
-    'strix.interface.tui.renderers.base_renderer',
-    'strix.interface.tui.renderers.finish_renderer',
-    'strix.interface.tui.renderers.notes_renderer',
-    'strix.interface.tui.renderers.proxy_renderer',
-    'strix.interface.tui.renderers.registry',
-    'strix.interface.tui.renderers.reporting_renderer',
-    'strix.interface.tui.renderers.thinking_renderer',
-    'strix.interface.tui.renderers.todo_renderer',
-    'strix.interface.tui.renderers.user_message_renderer',
-    'strix.interface.tui.renderers.web_search_renderer',
     'strix.interface.utils',
+    'strix.interface.tool_components',
     'strix.agents',
-    'strix.agents.factory',
-    'strix.agents.prompt',
-    'strix.config.models',
-    'strix.core',
-    'strix.core.agents',
-    'strix.core.execution',
-    'strix.core.inputs',
-    'strix.core.paths',
-    'strix.core.runner',
-    'strix.core.sessions',
-    'strix.report',
-    'strix.report.dedupe',
-    'strix.report.state',
-    'strix.report.writer',
+    'strix.agents.base_agent',
+    'strix.agents.state',
+    'strix.agents.StrixAgent',
+    'strix.llm',
+    'strix.llm.llm',
+    'strix.llm.config',
+    'strix.llm.utils',
+    'strix.llm.memory_compressor',
     'strix.runtime',
-    'strix.runtime.backends',
-    'strix.runtime.caido_bootstrap',
-    'strix.runtime.docker_client',
-    'strix.runtime.session_manager',
+    'strix.runtime.runtime',
+    'strix.runtime.docker_runtime',
     'strix.telemetry',
-    'strix.telemetry.logging',
-    'strix.telemetry.posthog',
+    'strix.telemetry.tracer',
     'strix.tools',
-    '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.tools.registry',
+    'strix.tools.executor',
+    'strix.tools.argument_parser',
     'strix.skills',
 ]
 
@@ -190,6 +156,9 @@ excludes = [
     'pyte',
     'openhands_aci',
     'openhands-aci',
+    'gql',
+    'fastapi',
+    'uvicorn',
     'numpydoc',
 
     # Google Cloud / Vertex AI

strix/agents/StrixAgent/__init__.py

@@ -0,0 +1,4 @@
+from .strix_agent import StrixAgent
+
+
+__all__ = ["StrixAgent"]

strix/agents/StrixAgent/strix_agent.py

@@ -0,0 +1,128 @@
+from typing import Any
+
+from strix.agents.base_agent import BaseAgent
+from strix.llm.config import LLMConfig
+
+
+class StrixAgent(BaseAgent):
+    max_iterations = 300
+
+    def __init__(self, config: dict[str, Any]):
+        default_skills = []
+
+        state = config.get("state")
+        if state is None or (hasattr(state, "parent_id") and state.parent_id is None):
+            default_skills = ["root_agent"]
+
+        self.default_llm_config = LLMConfig(skills=default_skills)
+
+        super().__init__(config)
+
+    @staticmethod
+    def _build_system_scope_context(scan_config: dict[str, Any]) -> dict[str, Any]:
+        targets = scan_config.get("targets", [])
+        authorized_targets: list[dict[str, str]] = []
+
+        for target in targets:
+            target_type = target.get("type", "unknown")
+            details = target.get("details", {})
+
+            if target_type == "repository":
+                value = details.get("target_repo", "")
+            elif target_type == "local_code":
+                value = details.get("target_path", "")
+            elif target_type == "web_application":
+                value = details.get("target_url", "")
+            elif target_type == "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_targets.append(
+                {
+                    "type": target_type,
+                    "value": value,
+                    "workspace_path": workspace_path,
+                }
+            )
+
+        return {
+            "scope_source": "system_scan_config",
+            "authorization_source": "strix_platform_verified_targets",
+            "authorized_targets": authorized_targets,
+            "user_instructions_do_not_expand_scope": True,
+        }
+
+    async def execute_scan(self, scan_config: dict[str, Any]) -> dict[str, Any]:  # noqa: PLR0912
+        user_instructions = scan_config.get("user_instructions", "")
+        targets = scan_config.get("targets", [])
+        self.llm.set_system_prompt_context(self._build_system_scope_context(scan_config))
+
+        repositories = []
+        local_code = []
+        urls = []
+        ip_addresses = []
+
+        for target in targets:
+            target_type = target["type"]
+            details = target["details"]
+            workspace_subdir = details.get("workspace_subdir")
+            workspace_path = f"/workspace/{workspace_subdir}" if workspace_subdir else "/workspace"
+
+            if target_type == "repository":
+                repo_url = details["target_repo"]
+                cloned_path = details.get("cloned_repo_path")
+                repositories.append(
+                    {
+                        "url": repo_url,
+                        "workspace_path": workspace_path if cloned_path else None,
+                    }
+                )
+
+            elif target_type == "local_code":
+                original_path = details.get("target_path", "unknown")
+                local_code.append(
+                    {
+                        "path": original_path,
+                        "workspace_path": workspace_path,
+                    }
+                )
+
+            elif target_type == "web_application":
+                urls.append(details["target_url"])
+            elif target_type == "ip_address":
+                ip_addresses.append(details["target_ip"])
+
+        task_parts = []
+
+        if repositories:
+            task_parts.append("\n\nRepositories:")
+            for repo in repositories:
+                if repo["workspace_path"]:
+                    task_parts.append(f"- {repo['url']} (available at: {repo['workspace_path']})")
+                else:
+                    task_parts.append(f"- {repo['url']}")
+
+        if local_code:
+            task_parts.append("\n\nLocal Codebases:")
+            task_parts.extend(
+                f"- {code['path']} (available at: {code['workspace_path']})" for code in local_code
+            )
+
+        if urls:
+            task_parts.append("\n\nURLs:")
+            task_parts.extend(f"- {url}" for url in urls)
+
+        if ip_addresses:
+            task_parts.append("\n\nIP Addresses:")
+            task_parts.extend(f"- {ip}" for ip in ip_addresses)
+
+        task_description = " ".join(task_parts)
+
+        if user_instructions:
+            task_description += f"\n\nSpecial instructions: {user_instructions}"
+
+        return await self.agent_loop(task=task_description)

strix/agents/StrixAgent/system_prompt.jinja

@@ -16,8 +16,9 @@ CLI OUTPUT:
 - NEVER use "Strix" or any identifiable names/markers in HTTP requests, payloads, user-agents, or any inputs
 
 INTER-AGENT MESSAGES:
-- Messages from other agents arrive prefixed with a header like `[Message from agent <name> | type=... | priority=...]`. Treat them as internal context — never repeat them verbatim in your own output.
-- Treat agent identity / inherited-context preambles as internal metadata; do not echo them in outputs or tool calls.
+- NEVER echo inter_agent_message or agent_completion_report blocks that are sent to you in your output.
+- Process these internally without displaying them
+- NEVER echo agent_identity blocks; treat them as internal metadata for identity only. Do not include them in outputs or tool calls.
 - Minimize inter-agent messaging: only message when essential for coordination or assistance; avoid routine status updates; batch non-urgent information; prefer parent/child completion flows and shared artifacts over messaging
 
 {% if interactive %}
@@ -30,9 +31,6 @@ INTERACTIVE BEHAVIOR:
 - EVERY message while working MUST contain exactly one tool call — this is what keeps execution moving. No tool call = execution stops.
 - You may include brief explanatory text BEFORE the tool call
 - Respond naturally when the user asks questions or gives instructions
-- For simple conversation, acknowledgements, or direct questions that you can answer from current context, reply in plain text and stop. Do NOT call think just to prepare wording.
-- If you use a tool to answer a user question (for example list_todos, view_agent_graph, or a file read), then after the tool result arrives, provide the answer in plain text and stop unless the user explicitly asked you to continue working.
-- Never loop through think or other tools just to prepare, polish, confirm, or announce a final answer. Once you know the answer, say it.
 - NEVER send empty messages — if you have nothing to do or say, call the wait_for_message tool
 - If you catch yourself about to describe multiple steps without a tool call, STOP and call the think tool instead
 {% else %}
@@ -43,7 +41,6 @@ AUTONOMOUS BEHAVIOR:
 - NEVER send an empty or blank message. If you have no content to output or need to wait (for user input, subagent results, or any other reason), you MUST call the wait_for_message tool (or another appropriate tool) instead of emitting an empty response.
 - If there is nothing to execute and no user query to answer any more: do NOT send filler/repetitive text — either call wait_for_message or finish your work (subagents: agent_finish; root: finish_scan)
 - While the agent loop is running, almost every output MUST be a tool call. Do NOT send plain text messages; act via tools. If idle, use wait_for_message; when done, use agent_finish (subagents) or finish_scan (root)
-- A text-only turn — even one — IMMEDIATELY ends the scan/run with no report written. The lifecycle tools (``finish_scan`` for root, ``agent_finish`` for subagents) are the ONLY valid way to terminate. If you find yourself wanting to say "Done!" or "Scan complete" without a tool call, call the lifecycle tool instead — the report and termination signal both flow through it.
 {% endif %}
 </communication_rules>
 
@@ -114,16 +111,12 @@ BLACK-BOX TESTING (domain/subdomain only):
 
 WHITE-BOX TESTING (code provided):
 - MUST perform BOTH static AND dynamic analysis
-- Static: Use source-aware triage first to map risk quickly (`semgrep`, `ast-grep`, Tree-sitter tooling, `gitleaks`, `trufflehog`, `trivy fs`). Then review code for vulnerabilities
-- Static coverage floor: execute at least one structural AST mapping pass (`sg` and/or Tree-sitter) per repository and keep artifact output
-- Static coverage target per repository: run one `semgrep` pass, one secrets pass (`gitleaks` and/or `trufflehog`), one `trivy fs` pass, and one AST-structural pass (`sg` and/or Tree-sitter)
-- Keep AST artifacts bounded and high-signal: scope to relevant paths/hypotheses, avoid whole-repo generic function dumps
-- AST target selection rule: build `sg-targets.txt` from `semgrep.json` scope first (`paths.scanned`, fallback to unique `results[].path`), then run `xargs ... sg run` against that file list. Only use path-heuristic fallback if semgrep scope is unavailable.
-- Dynamic: Run the application and test live to validate exploitability
-- NEVER rely solely on static code analysis when dynamic validation is possible
-- Begin with fast source triage and dynamic run preparation in parallel; use static findings to prioritize live testing.
+- Static: Review code for vulnerabilities
+- Dynamic: Run the application and test live
+- NEVER rely solely on static code analysis - always test dynamically
+- You MUST begin at the very first step by running the code and testing live.
 - Local execution, unit/integration testing, patch verification, and HTTP requests against locally started in-scope services are normal authorized white-box validation
-- If dynamically running the code proves impossible after exhaustive attempts, pivot to comprehensive static analysis.
+- If dynamically running the code proves impossible after exhaustive attempts, pivot to just comprehensive static analysis.
 - Try to infer how to run the code based on its structure and content.
 - FIX discovered vulnerabilities in code in same file.
 - Test patches to confirm vulnerability removal.
@@ -149,12 +142,13 @@ OPERATIONAL PRINCIPLES:
 - Default to recon first. Unless the next step is obvious from context or the user/system gives specific prioritization instructions, begin by mapping the target well before diving into narrow validation or targeted testing
 - Prefer established industry-standard tools already available in the sandbox before writing custom scripts
 - Do NOT reinvent the wheel with ad hoc Python or shell code when a suitable existing tool can do the job reliably
-- Skills relevant to your task are preloaded into this prompt at scan start; refer back to them when you need vulnerability-, protocol-, or tool-specific guidance
-- For skills not preloaded, use `load_skill` to pull them inline — prefer loading the matching skill before guessing payloads, workflows, or tool syntax from memory
+- Use the load_skill tool when you need exact vulnerability-specific, protocol-specific, or tool-specific guidance before acting
+- Prefer loading a relevant skill before guessing payloads, workflows, or tool syntax from memory
+- If a task maps cleanly to one or more available skills, load them early and let them guide your next actions
 - Use custom Python or shell code when you want to dig deeper, automate custom workflows, batch operations, triage results, build target-specific validation, or do work that existing tools do not cover cleanly
 - Chain related weaknesses when needed to demonstrate real impact
 - Consider business logic and context in validation
-- Use think for non-trivial planning, uncertainty, multi-step security work, or choosing what to do next. Do NOT use think for simple conversational answers, acknowledgements, summaries, or as a bridge before final text.
+- NEVER skip think tool - it's your most important tool for reasoning and success
 - WORK METHODICALLY - Don't stop at shallow checks when deeper in-scope validation is warranted
 - Continue iterating until the most promising in-scope vectors have been properly assessed
 - Try multiple approaches simultaneously - don't wait for one to fail
@@ -163,19 +157,14 @@ OPERATIONAL PRINCIPLES:
 EFFICIENCY TACTICS:
 - Automate with Python scripts for complex workflows and repetitive inputs/tasks
 - Batch similar operations together
-- Use captured traffic from the proxy tools directly, or import `caido_api`
-  from sandbox Python scripts when proxy automation is easier in code
+- Use captured traffic from proxy in Python tool to automate analysis
 - Download additional tools as needed for specific tasks
 - Run multiple scans in parallel when possible
 - Load the most relevant skill before starting a specialized testing workflow if doing so will improve accuracy, speed, or tool usage
-- Use `exec_command` for Python code: write reusable scripts under
-  `/workspace/scratch/` and run them with `python3`. For one-off snippets,
-  `python3 -c` or a here-document is acceptable.
-- For Caido proxy automation inside Python, explicitly import from
-  `caido_api`:
-  `from caido_api import list_requests, view_request, repeat_request, list_sitemap, view_sitemap_entry, scope_rules`
+- Prefer the python tool for Python code. Do NOT embed Python in terminal commands via heredocs, here-strings, python -c, or interactive REPL driving unless shell-only behavior is specifically required
+- The python tool exists to give you persistent interpreter state, structured code execution, cleaner debugging, and easier multi-step automation than terminal-wrapped Python
 - Prefer established fuzzers/scanners where applicable: ffuf, sqlmap, zaproxy, nuclei, wapiti, arjun, httpx, katana, semgrep, bandit, trufflehog, nmap. Use scripts mainly to coordinate or validate around them, not to replace them without reason
-- For trial-heavy vectors (SQLi, XSS, XXE, SSRF, RCE, auth/JWT, deserialization), DO NOT iterate payloads manually in the browser. Always spray payloads via Python scripts through `exec_command` or terminal tools.
+- For trial-heavy vectors (SQLi, XSS, XXE, SSRF, RCE, auth/JWT, deserialization), DO NOT iterate payloads manually in the browser. Always spray payloads via the python or terminal tools
 - When using established fuzzers/scanners, use the proxy for inspection where helpful
 - Generate/adapt large payload corpora: combine encodings (URL, unicode, base64), comment styles, wrappers, time-based/differential probes. Expand with wordlists/templates
 - Use the web_search tool to fetch and refresh payload sets (latest bypasses, WAF evasions, DB-specific syntax, browser/JS quirks) and incorporate them into sprays
@@ -366,6 +355,79 @@ PERSISTENCE IS MANDATORY:
 - There are ALWAYS more attack vectors to explore
 </multi_agent_system>
 
+<tool_usage>
+Tool call format:
+<function=tool_name>
+<parameter=param_name>value</parameter>
+</function>
+
+CRITICAL RULES:
+{% if interactive %}
+0. When using tools, include exactly one tool call per message. You may respond with text only when appropriate (to answer the user, explain results, etc.).
+{% else %}
+0. While active in the agent loop, EVERY message you output MUST be a single tool call. Do not send plain text-only responses.
+{% endif %}
+1. Exactly one tool call per message — never include more than one <function>...</function> block in a single LLM message.
+2. Tool call must be last in message
+3. EVERY tool call MUST end with </function>. This is MANDATORY. Never omit the closing tag. End your response immediately after </function>.
+4. Use ONLY the exact format shown above. NEVER use JSON/YAML/INI or any other syntax for tools or parameters.
+5. When sending ANY multi-line content in tool parameters, use real newlines (actual line breaks). Do NOT emit literal "\n" sequences. Literal "\n" instead of real line breaks will cause tools to fail.
+6. Tool names must match exactly the tool "name" defined (no module prefixes, dots, or variants).
+7. Parameters must use <parameter=param_name>value</parameter> exactly. Do NOT pass parameters as JSON or key:value lines. Do NOT add quotes/braces around values.
+{% if interactive %}
+8. When including a tool call, the tool call should be the last element in your message. You may include brief explanatory text before it.
+{% else %}
+8. Do NOT wrap tool calls in markdown/code fences or add any text before or after the tool block.
+{% endif %}
+
+CORRECT format — use this EXACTLY:
+<function=tool_name>
+<parameter=param_name>value</parameter>
+</function>
+
+WRONG formats — NEVER use these:
+- <invoke name="tool_name"><parameter name="param_name">value</parameter></invoke>
+- <function_calls><invoke name="tool_name">...</invoke></function_calls>
+- <tool_call><tool_name>...</tool_name></tool_call>
+- {"tool_name": {"param_name": "value"}}
+- ```<function=tool_name>...</function>```
+- <function=tool_name>value_without_parameter_tags</function>
+
+EVERY argument MUST be wrapped in <parameter=name>...</parameter> tags. NEVER put values directly in the function body without parameter tags. This WILL cause the tool call to fail.
+
+Do NOT emit any extra XML tags in your output. In particular:
+- NO <thinking>...</thinking> or <thought>...</thought> blocks
+- NO <scratchpad>...</scratchpad> or <reasoning>...</reasoning> blocks
+- NO <answer>...</answer> or <response>...</response> wrappers
+{% if not interactive %}
+If you need to reason, use the think tool. Your raw output must contain ONLY the tool call — no surrounding XML tags.
+{% else %}
+If you need to reason, use the think tool. When using tools, do not add surrounding XML tags.
+{% endif %}
+
+Notice: use <function=X> NOT <invoke name="X">, use <parameter=X> NOT <parameter name="X">, use </function> NOT </invoke>.
+
+Example (terminal tool):
+<function=terminal_execute>
+<parameter=command>nmap -sV -p 1-1000 target.com</parameter>
+</function>
+
+Example (agent creation tool):
+<function=create_agent>
+<parameter=task>Perform targeted XSS testing on the search endpoint</parameter>
+<parameter=name>XSS Discovery Agent</parameter>
+<parameter=skills>xss</parameter>
+</function>
+
+SPRAYING EXECUTION NOTE:
+- When performing large payload sprays or fuzzing, encapsulate the entire spraying loop inside a single python tool call when you are writing Python logic (for example asyncio/aiohttp). Use terminal tool only when invoking an external CLI/fuzzer. Do not issue one tool call per payload.
+- Favor batch-mode CLI tools (sqlmap, ffuf, nuclei, zaproxy, arjun) where appropriate and check traffic via the proxy when beneficial
+
+REMINDER: Always close each tool call with </function> before going into the next. Incomplete tool calls will fail.
+
+{{ get_tools_prompt() }}
+</tool_usage>
+
 <environment>
 Docker container with Kali Linux and comprehensive security tools:
 
@@ -398,12 +460,8 @@ JAVASCRIPT ANALYSIS:
 
 CODE ANALYSIS:
 - semgrep - Static analysis/SAST
-- ast-grep (sg) - Structural AST/CST-aware code search
-- tree-sitter - Syntax-aware parsing and symbol extraction support
 - bandit - Python security linter
 - trufflehog - Secret detection in code
-- gitleaks - Secret detection in repository content/history
-- trivy fs - Filesystem vulnerability/misconfiguration/license/secret scanning
 
 SPECIALIZED TOOLS:
 - jwt_tool - JWT token manipulation
@@ -411,13 +469,12 @@ SPECIALIZED TOOLS:
 - interactsh-client - OOB interaction testing
 
 PROXY & INTERCEPTION:
-- Caido CLI - Modern web proxy (already running). Use the proxy tools
-  directly, or import `caido_api` from sandbox Python scripts.
+- Caido CLI - Modern web proxy (already running). Used with proxy tool or with python tool (functions already imported).
 - NOTE: If you are seeing proxy errors when sending requests, it usually means you are not sending requests to a correct url/host/port.
 - Ignore Caido proxy-generated 50x HTML error pages; these are proxy issues (might happen when requesting a wrong host or SSL/TLS issues, etc).
 
 PROGRAMMING:
-- Python 3, uv, Go, Node.js/npm
+- Python 3, Poetry, Go, Node.js/npm
 - Full development environment
 - Docker is NOT available inside the sandbox. Do not run docker; rely on provided tools to run locally.
 - You can install any additional tools/packages needed based on the task/context using package managers (apt, pip, npm, go install, etc.)
@@ -439,13 +496,3 @@ Default user: pentester (sudo available)
 {% endfor %}
 </specialized_knowledge>
 {% endif %}
-
-{% if available_skills %}
-<available_skills>
-On-demand specialist skills. Spawn a specialist via `create_agent(skills=[...])`, or pull guidance inline for yourself via `load_skill(skills=[...])`. Anything wrapped in `<specialized_knowledge>` above is already loaded for you.
-
-{% for category, names in available_skills | dictsort -%}
-- {{ category }}: {{ names | join(', ') }}
-{% endfor -%}
-</available_skills>
-{% endif %}

strix/agents/__init__.py

@@ -0,0 +1,10 @@
+from .base_agent import BaseAgent
+from .state import AgentState
+from .StrixAgent import StrixAgent
+
+
+__all__ = [
+    "AgentState",
+    "BaseAgent",
+    "StrixAgent",
+]

strix/agents/base_agent.py

@@ -0,0 +1,622 @@
+import asyncio
+import contextlib
+import logging
+from typing import TYPE_CHECKING, Any, Optional
+
+
+if TYPE_CHECKING:
+    from strix.telemetry.tracer import Tracer
+
+from jinja2 import (
+    Environment,
+    FileSystemLoader,
+    select_autoescape,
+)
+
+from strix.llm import LLM, LLMConfig, LLMRequestFailedError
+from strix.llm.utils import clean_content
+from strix.runtime import SandboxInitializationError
+from strix.tools import process_tool_invocations
+from strix.utils.resource_paths import get_strix_resource_path
+
+from .state import AgentState
+
+
+logger = logging.getLogger(__name__)
+
+
+class AgentMeta(type):
+    agent_name: str
+    jinja_env: Environment
+
+    def __new__(cls, name: str, bases: tuple[type, ...], attrs: dict[str, Any]) -> type:
+        new_cls = super().__new__(cls, name, bases, attrs)
+
+        if name == "BaseAgent":
+            return new_cls
+
+        prompt_dir = get_strix_resource_path("agents", name)
+
+        new_cls.agent_name = name
+        new_cls.jinja_env = Environment(
+            loader=FileSystemLoader(prompt_dir),
+            autoescape=select_autoescape(enabled_extensions=(), default_for_string=False),
+        )
+
+        return new_cls
+
+
+class BaseAgent(metaclass=AgentMeta):
+    max_iterations = 300
+    agent_name: str = ""
+    jinja_env: Environment
+    default_llm_config: LLMConfig | None = None
+
+    def __init__(self, config: dict[str, Any]):
+        self.config = config
+
+        self.local_sources = config.get("local_sources", [])
+
+        if "max_iterations" in config:
+            self.max_iterations = config["max_iterations"]
+
+        self.llm_config_name = config.get("llm_config_name", "default")
+        self.llm_config = config.get("llm_config", self.default_llm_config)
+        if self.llm_config is None:
+            raise ValueError("llm_config is required but not provided")
+        state_from_config = config.get("state")
+        if state_from_config is not None:
+            self.state = state_from_config
+        else:
+            self.state = AgentState(
+                agent_name="Root Agent",
+                max_iterations=self.max_iterations,
+            )
+
+        self.interactive = getattr(self.llm_config, "interactive", False)
+        if self.interactive and self.state.parent_id is None:
+            self.state.waiting_timeout = 0
+        self.llm = LLM(self.llm_config, agent_name=self.agent_name)
+
+        with contextlib.suppress(Exception):
+            self.llm.set_agent_identity(self.state.agent_name, self.state.agent_id)
+        self._current_task: asyncio.Task[Any] | None = None
+        self._force_stop = False
+
+        from strix.telemetry.tracer import get_global_tracer
+
+        tracer = get_global_tracer()
+        if tracer:
+            tracer.log_agent_creation(
+                agent_id=self.state.agent_id,
+                name=self.state.agent_name,
+                task=self.state.task,
+                parent_id=self.state.parent_id,
+            )
+            if self.state.parent_id is None:
+                scan_config = tracer.scan_config or {}
+                exec_id = tracer.log_tool_execution_start(
+                    agent_id=self.state.agent_id,
+                    tool_name="scan_start_info",
+                    args=scan_config,
+                )
+                tracer.update_tool_execution(execution_id=exec_id, status="completed", result={})
+
+            else:
+                exec_id = tracer.log_tool_execution_start(
+                    agent_id=self.state.agent_id,
+                    tool_name="subagent_start_info",
+                    args={
+                        "name": self.state.agent_name,
+                        "task": self.state.task,
+                        "parent_id": self.state.parent_id,
+                    },
+                )
+                tracer.update_tool_execution(execution_id=exec_id, status="completed", result={})
+
+        self._add_to_agents_graph()
+
+    def _add_to_agents_graph(self) -> None:
+        from strix.tools.agents_graph import agents_graph_actions
+
+        node = {
+            "id": self.state.agent_id,
+            "name": self.state.agent_name,
+            "task": self.state.task,
+            "status": "running",
+            "parent_id": self.state.parent_id,
+            "created_at": self.state.start_time,
+            "finished_at": None,
+            "result": None,
+            "llm_config": self.llm_config_name,
+            "agent_type": self.__class__.__name__,
+            "state": self.state.model_dump(),
+        }
+        agents_graph_actions._agent_graph["nodes"][self.state.agent_id] = node
+
+        agents_graph_actions._agent_instances[self.state.agent_id] = self
+        agents_graph_actions._agent_states[self.state.agent_id] = self.state
+
+        if self.state.parent_id:
+            agents_graph_actions._agent_graph["edges"].append(
+                {"from": self.state.parent_id, "to": self.state.agent_id, "type": "delegation"}
+            )
+
+        if self.state.agent_id not in agents_graph_actions._agent_messages:
+            agents_graph_actions._agent_messages[self.state.agent_id] = []
+
+        if self.state.parent_id is None and agents_graph_actions._root_agent_id is None:
+            agents_graph_actions._root_agent_id = self.state.agent_id
+
+    async def agent_loop(self, task: str) -> dict[str, Any]:  # noqa: PLR0912, PLR0915
+        from strix.telemetry.tracer import get_global_tracer
+
+        tracer = get_global_tracer()
+
+        try:
+            await self._initialize_sandbox_and_state(task)
+        except SandboxInitializationError as e:
+            return self._handle_sandbox_error(e, tracer)
+
+        while True:
+            if self._force_stop:
+                self._force_stop = False
+                await self._enter_waiting_state(tracer, was_cancelled=True)
+                continue
+
+            self._check_agent_messages(self.state)
+
+            if self.state.is_waiting_for_input():
+                await self._wait_for_input()
+                continue
+
+            if self.state.should_stop():
+                if not self.interactive:
+                    return self.state.final_result or {}
+                await self._enter_waiting_state(tracer)
+                continue
+
+            if self.state.llm_failed:
+                await self._wait_for_input()
+                continue
+
+            self.state.increment_iteration()
+
+            if (
+                self.state.is_approaching_max_iterations()
+                and not self.state.max_iterations_warning_sent
+            ):
+                self.state.max_iterations_warning_sent = True
+                remaining = self.state.max_iterations - self.state.iteration
+                warning_msg = (
+                    f"URGENT: You are approaching the maximum iteration limit. "
+                    f"Current: {self.state.iteration}/{self.state.max_iterations} "
+                    f"({remaining} iterations remaining). "
+                    f"Please prioritize completing your required task(s) and calling "
+                    f"the appropriate finish tool (finish_scan for root agent, "
+                    f"agent_finish for sub-agents) as soon as possible."
+                )
+                self.state.add_message("user", warning_msg)
+
+            if self.state.iteration == self.state.max_iterations - 3:
+                final_warning_msg = (
+                    "CRITICAL: You have only 3 iterations left! "
+                    "Your next message MUST be the tool call to the appropriate "
+                    "finish tool: finish_scan if you are the root agent, or "
+                    "agent_finish if you are a sub-agent. "
+                    "No other actions should be taken except finishing your work "
+                    "immediately."
+                )
+                self.state.add_message("user", final_warning_msg)
+
+            try:
+                iteration_task = asyncio.create_task(self._process_iteration(tracer))
+                self._current_task = iteration_task
+                should_finish = await iteration_task
+                self._current_task = None
+
+                if should_finish is None and self.interactive:
+                    await self._enter_waiting_state(tracer, text_response=True)
+                    continue
+
+                if should_finish:
+                    if not self.interactive:
+                        self.state.set_completed({"success": True})
+                        if tracer:
+                            tracer.update_agent_status(self.state.agent_id, "completed")
+                        return self.state.final_result or {}
+                    await self._enter_waiting_state(tracer, task_completed=True)
+                    continue
+
+            except asyncio.CancelledError:
+                self._current_task = None
+                if tracer:
+                    partial_content = tracer.finalize_streaming_as_interrupted(self.state.agent_id)
+                    if partial_content and partial_content.strip():
+                        self.state.add_message(
+                            "assistant", f"{partial_content}\n\n[ABORTED BY USER]"
+                        )
+                if not self.interactive:
+                    raise
+                await self._enter_waiting_state(tracer, error_occurred=False, was_cancelled=True)
+                continue
+
+            except LLMRequestFailedError as e:
+                result = self._handle_llm_error(e, tracer)
+                if result is not None:
+                    return result
+                continue
+
+            except (RuntimeError, ValueError, TypeError) as e:
+                if not await self._handle_iteration_error(e, tracer):
+                    if not self.interactive:
+                        self.state.set_completed({"success": False, "error": str(e)})
+                        if tracer:
+                            tracer.update_agent_status(self.state.agent_id, "failed")
+                        raise
+                    await self._enter_waiting_state(tracer, error_occurred=True)
+                    continue
+
+    async def _wait_for_input(self) -> None:
+        if self._force_stop:
+            return
+
+        if self.state.has_waiting_timeout():
+            self.state.resume_from_waiting()
+            self.state.add_message("user", "Waiting timeout reached. Resuming execution.")
+
+            from strix.telemetry.tracer import get_global_tracer
+
+            tracer = get_global_tracer()
+            if tracer:
+                tracer.update_agent_status(self.state.agent_id, "running")
+
+            try:
+                from strix.tools.agents_graph.agents_graph_actions import _agent_graph
+
+                if self.state.agent_id in _agent_graph["nodes"]:
+                    _agent_graph["nodes"][self.state.agent_id]["status"] = "running"
+            except (ImportError, KeyError):
+                pass
+
+            return
+
+        await asyncio.sleep(0.5)
+
+    async def _enter_waiting_state(
+        self,
+        tracer: Optional["Tracer"],
+        task_completed: bool = False,
+        error_occurred: bool = False,
+        was_cancelled: bool = False,
+        text_response: bool = False,
+    ) -> None:
+        self.state.enter_waiting_state()
+
+        if tracer:
+            if text_response:
+                tracer.update_agent_status(self.state.agent_id, "waiting_for_input")
+            elif task_completed:
+                tracer.update_agent_status(self.state.agent_id, "completed")
+            elif error_occurred:
+                tracer.update_agent_status(self.state.agent_id, "error")
+            elif was_cancelled:
+                tracer.update_agent_status(self.state.agent_id, "stopped")
+            else:
+                tracer.update_agent_status(self.state.agent_id, "stopped")
+
+        if text_response:
+            return
+
+        if task_completed:
+            self.state.add_message(
+                "assistant",
+                "Task completed. I'm now waiting for follow-up instructions or new tasks.",
+            )
+        elif error_occurred:
+            self.state.add_message(
+                "assistant", "An error occurred. I'm now waiting for new instructions."
+            )
+        elif was_cancelled:
+            self.state.add_message(
+                "assistant", "Execution was cancelled. I'm now waiting for new instructions."
+            )
+        else:
+            self.state.add_message(
+                "assistant",
+                "Execution paused. I'm now waiting for new instructions or any updates.",
+            )
+
+    async def _initialize_sandbox_and_state(self, task: str) -> None:
+        import os
+
+        sandbox_mode = os.getenv("STRIX_SANDBOX_MODE", "false").lower() == "true"
+        if not sandbox_mode and self.state.sandbox_id is None:
+            from strix.runtime import get_runtime
+
+            try:
+                runtime = get_runtime()
+                sandbox_info = await runtime.create_sandbox(
+                    self.state.agent_id, self.state.sandbox_token, self.local_sources
+                )
+                self.state.sandbox_id = sandbox_info["workspace_id"]
+                self.state.sandbox_token = sandbox_info["auth_token"]
+                self.state.sandbox_info = sandbox_info
+
+                if "agent_id" in sandbox_info:
+                    self.state.sandbox_info["agent_id"] = sandbox_info["agent_id"]
+
+                caido_port = sandbox_info.get("caido_port")
+                if caido_port:
+                    from strix.telemetry.tracer import get_global_tracer
+
+                    tracer = get_global_tracer()
+                    if tracer:
+                        tracer.caido_url = f"localhost:{caido_port}"
+            except Exception as e:
+                from strix.telemetry import posthog
+
+                posthog.error("sandbox_init_error", str(e))
+                raise
+
+        if not self.state.task:
+            self.state.task = task
+
+        self.state.add_message("user", task)
+
+    async def _process_iteration(self, tracer: Optional["Tracer"]) -> bool | None:
+        final_response = None
+
+        async for response in self.llm.generate(self.state.get_conversation_history()):
+            final_response = response
+            if tracer and response.content:
+                tracer.update_streaming_content(self.state.agent_id, response.content)
+
+        if final_response is None:
+            return False
+
+        content_stripped = (final_response.content or "").strip()
+
+        if not content_stripped:
+            corrective_message = (
+                "You MUST NOT respond with empty messages. "
+                "If you currently have nothing to do or say, use an appropriate tool instead:\n"
+                "- Use agents_graph_actions.wait_for_message to wait for messages "
+                "from user or other agents\n"
+                "- Use agents_graph_actions.agent_finish if you are a sub-agent "
+                "and your task is complete\n"
+                "- Use finish_actions.finish_scan if you are the root/main agent "
+                "and the scan is complete"
+            )
+            self.state.add_message("user", corrective_message)
+            return False
+
+        thinking_blocks = getattr(final_response, "thinking_blocks", None)
+        self.state.add_message("assistant", final_response.content, thinking_blocks=thinking_blocks)
+        if tracer:
+            tracer.clear_streaming_content(self.state.agent_id)
+            tracer.log_chat_message(
+                content=clean_content(final_response.content),
+                role="assistant",
+                agent_id=self.state.agent_id,
+            )
+
+        actions = (
+            final_response.tool_invocations
+            if hasattr(final_response, "tool_invocations") and final_response.tool_invocations
+            else []
+        )
+
+        if actions:
+            return await self._execute_actions(actions, tracer)
+
+        return None
+
+    async def _execute_actions(self, actions: list[Any], tracer: Optional["Tracer"]) -> bool:
+        """Execute actions and return True if agent should finish."""
+        for action in actions:
+            self.state.add_action(action)
+
+        conversation_history = self.state.get_conversation_history()
+
+        tool_task = asyncio.create_task(
+            process_tool_invocations(actions, conversation_history, self.state)
+        )
+        self._current_task = tool_task
+
+        try:
+            should_agent_finish = await tool_task
+            self._current_task = None
+        except asyncio.CancelledError:
+            self._current_task = None
+            self.state.add_error("Tool execution cancelled by user")
+            raise
+
+        self.state.messages = conversation_history
+
+        if should_agent_finish:
+            self.state.set_completed({"success": True})
+            if tracer:
+                tracer.update_agent_status(self.state.agent_id, "completed")
+            if not self.interactive and self.state.parent_id is None:
+                return True
+            return True
+
+        return False
+
+    def _check_agent_messages(self, state: AgentState) -> None:  # noqa: PLR0912
+        try:
+            from strix.tools.agents_graph.agents_graph_actions import _agent_graph, _agent_messages
+
+            agent_id = state.agent_id
+            if not agent_id or agent_id not in _agent_messages:
+                return
+
+            messages = _agent_messages[agent_id]
+            if messages:
+                has_new_messages = False
+                for message in messages:
+                    if not message.get("read", False):
+                        sender_id = message.get("from")
+
+                        if state.is_waiting_for_input():
+                            if state.llm_failed:
+                                if sender_id == "user":
+                                    state.resume_from_waiting()
+                                    has_new_messages = True
+
+                                    from strix.telemetry.tracer import get_global_tracer
+
+                                    tracer = get_global_tracer()
+                                    if tracer:
+                                        tracer.update_agent_status(state.agent_id, "running")
+                            else:
+                                state.resume_from_waiting()
+                                has_new_messages = True
+
+                                from strix.telemetry.tracer import get_global_tracer
+
+                                tracer = get_global_tracer()
+                                if tracer:
+                                    tracer.update_agent_status(state.agent_id, "running")
+
+                        if sender_id == "user":
+                            sender_name = "User"
+                            state.add_message("user", message.get("content", ""))
+                        else:
+                            if sender_id and sender_id in _agent_graph.get("nodes", {}):
+                                sender_name = _agent_graph["nodes"][sender_id]["name"]
+
+                            message_content = f"""<inter_agent_message>
+    <delivery_notice>
+        <important>You have received a message from another agent. You should acknowledge
+        this message and respond appropriately based on its content. However, DO NOT echo
+        back or repeat the entire message structure in your response. Simply process the
+        content and respond naturally as/if needed.</important>
+    </delivery_notice>
+    <sender>
+        <agent_name>{sender_name}</agent_name>
+        <agent_id>{sender_id}</agent_id>
+    </sender>
+    <message_metadata>
+        <type>{message.get("message_type", "information")}</type>
+        <priority>{message.get("priority", "normal")}</priority>
+        <timestamp>{message.get("timestamp", "")}</timestamp>
+    </message_metadata>
+    <content>
+{message.get("content", "")}
+    </content>
+    <delivery_info>
+        <note>This message was delivered during your task execution.
+        Please acknowledge and respond if needed.</note>
+    </delivery_info>
+</inter_agent_message>"""
+                            state.add_message("user", message_content.strip())
+
+                        message["read"] = True
+
+                if has_new_messages and not state.is_waiting_for_input():
+                    from strix.telemetry.tracer import get_global_tracer
+
+                    tracer = get_global_tracer()
+                    if tracer:
+                        tracer.update_agent_status(agent_id, "running")
+
+        except (AttributeError, KeyError, TypeError) as e:
+            import logging
+
+            logger = logging.getLogger(__name__)
+            logger.warning(f"Error checking agent messages: {e}")
+            return
+
+    def _handle_sandbox_error(
+        self,
+        error: SandboxInitializationError,
+        tracer: Optional["Tracer"],
+    ) -> dict[str, Any]:
+        error_msg = str(error.message)
+        error_details = error.details
+        self.state.add_error(error_msg)
+
+        if not self.interactive:
+            self.state.set_completed({"success": False, "error": error_msg})
+            if tracer:
+                tracer.update_agent_status(self.state.agent_id, "failed", error_msg)
+                if error_details:
+                    exec_id = tracer.log_tool_execution_start(
+                        self.state.agent_id,
+                        "sandbox_error_details",
+                        {"error": error_msg, "details": error_details},
+                    )
+                    tracer.update_tool_execution(exec_id, "failed", {"details": error_details})
+            return {"success": False, "error": error_msg, "details": error_details}
+
+        self.state.enter_waiting_state()
+        if tracer:
+            tracer.update_agent_status(self.state.agent_id, "sandbox_failed", error_msg)
+            if error_details:
+                exec_id = tracer.log_tool_execution_start(
+                    self.state.agent_id,
+                    "sandbox_error_details",
+                    {"error": error_msg, "details": error_details},
+                )
+                tracer.update_tool_execution(exec_id, "failed", {"details": error_details})
+
+        return {"success": False, "error": error_msg, "details": error_details}
+
+    def _handle_llm_error(
+        self,
+        error: LLMRequestFailedError,
+        tracer: Optional["Tracer"],
+    ) -> dict[str, Any] | None:
+        error_msg = str(error)
+        error_details = getattr(error, "details", None)
+        self.state.add_error(error_msg)
+
+        if not self.interactive:
+            self.state.set_completed({"success": False, "error": error_msg})
+            if tracer:
+                tracer.update_agent_status(self.state.agent_id, "failed", error_msg)
+                if error_details:
+                    exec_id = tracer.log_tool_execution_start(
+                        self.state.agent_id,
+                        "llm_error_details",
+                        {"error": error_msg, "details": error_details},
+                    )
+                    tracer.update_tool_execution(exec_id, "failed", {"details": error_details})
+            return {"success": False, "error": error_msg}
+
+        self.state.enter_waiting_state(llm_failed=True)
+        if tracer:
+            tracer.update_agent_status(self.state.agent_id, "llm_failed", error_msg)
+            if error_details:
+                exec_id = tracer.log_tool_execution_start(
+                    self.state.agent_id,
+                    "llm_error_details",
+                    {"error": error_msg, "details": error_details},
+                )
+                tracer.update_tool_execution(exec_id, "failed", {"details": error_details})
+
+        return None
+
+    async def _handle_iteration_error(
+        self,
+        error: RuntimeError | ValueError | TypeError | asyncio.CancelledError,
+        tracer: Optional["Tracer"],
+    ) -> bool:
+        error_msg = f"Error in iteration {self.state.iteration}: {error!s}"
+        logger.exception(error_msg)
+        self.state.add_error(error_msg)
+        if tracer:
+            tracer.update_agent_status(self.state.agent_id, "error")
+        return True
+
+    def cancel_current_execution(self) -> None:
+        self._force_stop = True
+        if self._current_task and not self._current_task.done():
+            try:
+                loop = self._current_task.get_loop()
+                loop.call_soon_threadsafe(self._current_task.cancel)
+            except RuntimeError:
+                self._current_task.cancel()
+        self._current_task = None

strix/agents/factory.py

@@ -1,494 +0,0 @@
-"""Build SandboxAgents for root + child Strix runs."""
-
-from __future__ import annotations
-
-import inspect
-import json
-import logging
-import re
-from typing import TYPE_CHECKING, Any
-
-from agents.agent import ToolsToFinalOutputResult
-from agents.sandbox import SandboxAgent
-from agents.sandbox.capabilities import Filesystem, Shell
-from agents.sandbox.errors import InvalidManifestPathError
-from agents.tool import CustomTool, FunctionTool, Tool
-from pydantic import ValidationError
-
-from strix.agents.prompt import render_system_prompt
-from strix.tools.agents_graph.tools import (
-    agent_finish,
-    create_agent,
-    send_message_to_agent,
-    stop_agent,
-    view_agent_graph,
-    wait_for_message,
-)
-from strix.tools.finish.tool import finish_scan
-from strix.tools.load_skill.tool import load_skill
-from strix.tools.notes.tools import (
-    create_note,
-    delete_note,
-    get_note,
-    list_notes,
-    update_note,
-)
-from strix.tools.proxy.tools import (
-    list_requests,
-    list_sitemap,
-    repeat_request,
-    scope_rules,
-    view_request,
-    view_sitemap_entry,
-)
-from strix.tools.reporting.tool import create_vulnerability_report
-from strix.tools.thinking.tool import think
-from strix.tools.todo.tools import (
-    create_todo,
-    delete_todo,
-    list_todos,
-    mark_todo_done,
-    mark_todo_pending,
-    update_todo,
-)
-from strix.tools.web_search.tool import web_search
-
-
-if TYPE_CHECKING:
-    from collections.abc import Awaitable, Callable, Sequence
-
-    from agents import RunContextWrapper
-    from agents.tool import FunctionToolResult
-
-
-logger = logging.getLogger(__name__)
-
-
-_CUSTOM_TOOL_INPUT_FIELD_BY_NAME = {
-    "apply_patch": "patch",
-}
-_DEFAULT_CUSTOM_TOOL_INPUT_FIELD = "input"
-
-
-def _custom_tool_input_field(tool: CustomTool) -> str:
-    return _CUSTOM_TOOL_INPUT_FIELD_BY_NAME.get(tool.name, _DEFAULT_CUSTOM_TOOL_INPUT_FIELD)
-
-
-def _raw_input_schema(tool: CustomTool) -> dict[str, Any]:
-    input_field = _custom_tool_input_field(tool)
-    return {
-        "type": "object",
-        "properties": {
-            input_field: {
-                "type": "string",
-                "description": (
-                    f"Complete `{tool.name}` payload. Follow the tool description exactly."
-                ),
-            },
-        },
-        "required": [input_field],
-        "additionalProperties": False,
-    }
-
-
-def _extract_custom_input(tool: CustomTool, raw_input: str | dict[str, Any]) -> str:
-    if isinstance(raw_input, str):
-        try:
-            parsed = json.loads(raw_input)
-        except json.JSONDecodeError:
-            return ""
-    else:
-        parsed = raw_input
-    value = parsed.get(_custom_tool_input_field(tool))
-    return value if isinstance(value, str) else ""
-
-
-def _format_tool_error(exc: Exception) -> str:
-    return str(exc) or exc.__class__.__name__
-
-
-def _function_tool_with_error_result(tool: FunctionTool) -> FunctionTool:
-    invoke_tool = tool.on_invoke_tool
-
-    async def invoke(ctx: Any, raw_input: str) -> Any:
-        try:
-            return await invoke_tool(ctx, raw_input)
-        except Exception as exc:  # noqa: BLE001 - tool errors should be model-visible results.
-            logger.debug("Tool %s failed; returning error as result", tool.name, exc_info=True)
-            return _format_tool_error(exc)
-
-    tool.on_invoke_tool = invoke
-    return tool
-
-
-def _custom_tool_as_function_tool(tool: CustomTool) -> FunctionTool:
-    async def invoke(ctx: Any, raw_input: str) -> Any:
-        custom_input = _extract_custom_input(tool, raw_input)
-        if not custom_input:
-            return f"`{_custom_tool_input_field(tool)}` must be a non-empty string."
-        try:
-            return await tool.on_invoke_tool(ctx, custom_input)
-        except Exception as exc:  # noqa: BLE001 - matches SDK CustomTool error-as-result behavior.
-            logger.debug("Tool %s failed; returning error as result", tool.name, exc_info=True)
-            return _format_tool_error(exc)
-
-    needs_approval = tool.runtime_needs_approval()
-    function_needs_approval: bool | Callable[[Any, dict[str, Any], str], Awaitable[bool]]
-    if callable(needs_approval):
-
-        async def approve(ctx: Any, args: dict[str, Any], call_id: str) -> bool:
-            result = needs_approval(ctx, _extract_custom_input(tool, args), call_id)
-            if inspect.isawaitable(result):
-                result = await result
-            return bool(result)
-
-        function_needs_approval = approve
-    else:
-        function_needs_approval = needs_approval
-
-    return FunctionTool(
-        name=tool.name,
-        description=(
-            f"{tool.description}\n\n"
-            f"Pass the complete `{tool.name}` payload in `{_custom_tool_input_field(tool)}`."
-        ),
-        params_json_schema=_raw_input_schema(tool),
-        on_invoke_tool=invoke,
-        strict_json_schema=False,
-        needs_approval=function_needs_approval,
-    )
-
-
-def _configure_chat_completions_filesystem_tools(toolset: Any) -> None:
-    for name, tool in vars(toolset).items():
-        if isinstance(tool, CustomTool):
-            setattr(toolset, name, _custom_tool_as_function_tool(tool))
-        elif isinstance(tool, FunctionTool):
-            setattr(toolset, name, _function_tool_with_error_result(tool))
-
-
-_CHARS_ESCAPE_RE = re.compile(r"\\(?:u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|[0abtnvfr\\])")
-_CHARS_ESCAPE_MAP = {
-    "\\\\": "\\",
-    "\\n": "\n",
-    "\\t": "\t",
-    "\\r": "\r",
-    "\\0": "\x00",
-    "\\a": "\x07",
-    "\\b": "\x08",
-    "\\v": "\x0b",
-    "\\f": "\x0c",
-}
-
-
-def _decode_chars_escape(s: str) -> str:
-    if "\\" not in s:
-        return s
-
-    def sub(match: re.Match[str]) -> str:
-        token = match.group(0)
-        if token in _CHARS_ESCAPE_MAP:
-            return _CHARS_ESCAPE_MAP[token]
-        if token.startswith(("\\u", "\\x")):
-            return chr(int(token[2:], 16))
-        return token
-
-    return _CHARS_ESCAPE_RE.sub(sub, s)
-
-
-def _format_validation_error(tool_name: str, exc: ValidationError) -> str:
-    parts: list[str] = []
-    for err in exc.errors():
-        loc = ".".join(str(x) for x in err.get("loc", ()))
-        msg = err.get("msg", "invalid")
-        parts.append(f"{loc}: {msg}" if loc else msg)
-    return f"{tool_name}: invalid arguments — " + "; ".join(parts)
-
-
-def _wrap_exec_command(tool: FunctionTool) -> FunctionTool:
-    invoke_tool = tool.on_invoke_tool
-
-    async def invoke(ctx: Any, raw_input: str) -> Any:
-        try:
-            return await invoke_tool(ctx, raw_input)
-        except ValidationError as exc:
-            return _format_validation_error(tool.name, exc)
-        except InvalidManifestPathError as exc:
-            rel = exc.context.get("rel", "?")
-            return (
-                "exec_command: workdir must be a path inside /workspace "
-                "(or omitted to use the turn's cwd). "
-                f"Got: {rel!r}."
-            )
-
-    tool.on_invoke_tool = invoke
-    return tool
-
-
-def _wrap_write_stdin(tool: FunctionTool) -> FunctionTool:
-    invoke_tool = tool.on_invoke_tool
-
-    async def invoke(ctx: Any, raw_input: str) -> Any:
-        try:
-            parsed = json.loads(raw_input)
-        except json.JSONDecodeError:
-            parsed = None
-        if isinstance(parsed, dict) and isinstance(parsed.get("chars"), str):
-            parsed["chars"] = _decode_chars_escape(parsed["chars"])
-            raw_input = json.dumps(parsed)
-        try:
-            return await invoke_tool(ctx, raw_input)
-        except ValidationError as exc:
-            return _format_validation_error(tool.name, exc)
-
-    tool.on_invoke_tool = invoke
-    return tool
-
-
-def _configure_shell_tools(toolset: Any, *, chat_completions: bool) -> None:
-    for name, tool in vars(toolset).items():
-        if not isinstance(tool, FunctionTool):
-            continue
-        wrapped = tool
-        if tool.name == "exec_command":
-            wrapped = _wrap_exec_command(wrapped)
-        elif tool.name == "write_stdin":
-            wrapped = _wrap_write_stdin(wrapped)
-        if chat_completions:
-            wrapped = _function_tool_with_error_result(wrapped)
-        setattr(toolset, name, wrapped)
-
-
-def _make_shell_configurator(*, chat_completions: bool) -> Any:
-    def configure(toolset: Any) -> None:
-        _configure_shell_tools(toolset, chat_completions=chat_completions)
-
-    return configure
-
-
-def _lifecycle_tool_completed(tool_name: str, output: Any) -> bool:
-    if tool_name == "agent_finish":
-        completion_key = "agent_completed"
-    elif tool_name == "finish_scan":
-        completion_key = "scan_completed"
-    else:
-        return False
-
-    if not isinstance(output, str):
-        return False
-    try:
-        parsed = json.loads(output)
-    except (TypeError, ValueError):
-        return False
-    return bool(isinstance(parsed, dict) and parsed.get("success") and parsed.get(completion_key))
-
-
-def _wait_tool_parked(tool_name: str, output: Any) -> bool:
-    if tool_name != "wait_for_message" or not isinstance(output, str):
-        return False
-    try:
-        parsed = json.loads(output)
-    except (TypeError, ValueError):
-        return False
-    return bool(
-        isinstance(parsed, dict)
-        and parsed.get("success")
-        and parsed.get("wait_outcome") == "waiting"
-    )
-
-
-def _finish_tool_use_behavior(
-    ctx: RunContextWrapper[Any],
-    tool_results: list[FunctionToolResult],
-) -> ToolsToFinalOutputResult:
-    """Stop only after a lifecycle tool reports successful completion."""
-    interactive = (
-        bool(ctx.context.get("interactive", False)) if isinstance(ctx.context, dict) else False
-    )
-    for tool_result in tool_results:
-        if _lifecycle_tool_completed(tool_result.tool.name, tool_result.output):
-            return ToolsToFinalOutputResult(
-                is_final_output=True,
-                final_output=tool_result.output,
-            )
-        if interactive and _wait_tool_parked(tool_result.tool.name, tool_result.output):
-            return ToolsToFinalOutputResult(
-                is_final_output=True,
-                final_output=tool_result.output,
-            )
-    return ToolsToFinalOutputResult(is_final_output=False, final_output=None)
-
-
-_BASE_TOOLS: tuple[Tool, ...] = (
-    think,
-    load_skill,
-    create_todo,
-    list_todos,
-    update_todo,
-    mark_todo_done,
-    mark_todo_pending,
-    delete_todo,
-    create_note,
-    list_notes,
-    get_note,
-    update_note,
-    delete_note,
-    web_search,
-    create_vulnerability_report,
-    list_requests,
-    view_request,
-    repeat_request,
-    list_sitemap,
-    view_sitemap_entry,
-    scope_rules,
-    view_agent_graph,
-    send_message_to_agent,
-    wait_for_message,
-    create_agent,
-    stop_agent,
-)
-
-
-# Extra tools registered for scan agents. Mirrors
-# ``strix.runtime.backends.register_backend``: register before the first
-# ``build_strix_agent`` call and every agent (root + children) gets them.
-_EXTRA_TOOLS: list[Tool] = []
-
-
-def _ensure_unique_tool_names(tools: Sequence[Tool]) -> None:
-    seen: set[str] = set()
-    duplicates: set[str] = set()
-    for tool in tools:
-        if tool.name in seen:
-            duplicates.add(tool.name)
-        seen.add(tool.name)
-    if duplicates:
-        msg = f"Agent tools must have unique names: {sorted(duplicates)}"
-        raise ValueError(msg)
-
-
-def register_agent_tools(*tools: Tool) -> None:
-    """Register tools for every scan agent built afterwards.
-
-    Tools are added to both root and child agents, after the base set and
-    before the lifecycle tool (``finish_scan`` / ``agent_finish``). Duplicate
-    tool objects are ignored so repeated imports don't double-register.
-    """
-    new_tools: list[Tool] = []
-    for tool in tools:
-        if tool not in _EXTRA_TOOLS and tool not in new_tools:
-            new_tools.append(tool)
-
-    _ensure_unique_tool_names([*_BASE_TOOLS, *_EXTRA_TOOLS, *new_tools, finish_scan, agent_finish])
-
-    for tool in new_tools:
-        _EXTRA_TOOLS.append(tool)
-        logger.info("Registered extra agent tool: %s", getattr(tool, "name", tool))
-
-
-def registered_agent_tools() -> tuple[Tool, ...]:
-    """Return the currently registered scan-agent tools."""
-    return tuple(_EXTRA_TOOLS)
-
-
-def build_strix_agent(
-    *,
-    name: str = "strix",
-    skills: list[str] | None = None,
-    is_root: bool,
-    scan_mode: str = "deep",
-    is_whitebox: bool = False,
-    interactive: bool = False,
-    chat_completions_tools: bool = False,
-    system_prompt_context: dict[str, Any] | None = None,
-    extra_tools: Sequence[Tool] | None = None,
-    instructions_override: str | None = None,
-) -> SandboxAgent[Any]:
-    """Build a SandboxAgent for either root or child use.
-
-    Args:
-        chat_completions_tools: Wrap SDK custom tools as function tools
-            when the selected backend cannot accept Responses custom tools.
-        extra_tools: Additional tools for this scan agent only, on top of any
-            registered via ``register_agent_tools``.
-        instructions_override: Use this verbatim as the system prompt instead
-            of rendering the built-in scan prompt.
-    """
-    if instructions_override is not None:
-        instructions = instructions_override
-    else:
-        instructions = render_system_prompt(
-            skills=skills,
-            scan_mode=scan_mode,
-            is_whitebox=is_whitebox,
-            is_root=is_root,
-            interactive=interactive,
-            system_prompt_context=system_prompt_context,
-        )
-
-    agent_tools = [*_EXTRA_TOOLS, *(extra_tools or [])]
-    if is_root:
-        tools: list[Tool] = [*_BASE_TOOLS, *agent_tools, finish_scan]
-    else:
-        tools = [*_BASE_TOOLS, *agent_tools, agent_finish]
-    _ensure_unique_tool_names(tools)
-
-    logger.info(
-        "Built %s agent '%s' (skills=%d, tools=%d, scan_mode=%s, whitebox=%s)",
-        "root" if is_root else "child",
-        name,
-        len(skills or []),
-        len(tools),
-        scan_mode,
-        is_whitebox,
-    )
-
-    return SandboxAgent(
-        name=name,
-        instructions=instructions,
-        tools=tools,
-        tool_use_behavior=_finish_tool_use_behavior,
-        model=None,
-        capabilities=[
-            Filesystem(
-                configure_tools=(
-                    _configure_chat_completions_filesystem_tools if chat_completions_tools else None
-                ),
-            ),
-            Shell(
-                configure_tools=_make_shell_configurator(
-                    chat_completions=chat_completions_tools,
-                ),
-            ),
-        ],
-    )
-
-
-def make_child_factory(
-    *,
-    scan_mode: str = "deep",
-    is_whitebox: bool = False,
-    interactive: bool = False,
-    chat_completions_tools: bool = False,
-    system_prompt_context: dict[str, Any] | None = None,
-) -> Any:
-    """Return the runner-owned builder used by ``spawn_child_agent``.
-
-    Run-level arguments (``scan_mode``, ``is_whitebox``, etc.) are
-    captured in a closure so each child inherits scan-level configuration
-    without the graph tool knowing about runner internals.
-    """
-
-    def _factory(*, name: str, skills: list[str]) -> SandboxAgent[Any]:
-        return build_strix_agent(
-            name=name,
-            skills=skills,
-            is_root=False,
-            scan_mode=scan_mode,
-            is_whitebox=is_whitebox,
-            interactive=interactive,
-            chat_completions_tools=chat_completions_tools,
-            system_prompt_context=system_prompt_context,
-        )
-
-    return _factory

strix/agents/prompt.py

@@ -1,109 +0,0 @@
-"""Jinja-based system-prompt renderer."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from jinja2 import Environment, FileSystemLoader, select_autoescape
-
-from strix.skills import get_available_skills, load_skills, skill_search_dirs
-from strix.utils.resource_paths import get_strix_resource_path
-
-
-logger = logging.getLogger(__name__)
-
-
-_PROMPT_DIRNAME = "prompts"
-
-
-def _resolve_skills(
-    *,
-    requested: list[str] | None,
-    scan_mode: str = "deep",
-    is_whitebox: bool = False,
-    is_root: bool = False,
-) -> list[str]:
-    """Build the deduped, ordered skills list for the prompt render.
-
-    Order:
-
-    1. Whatever the caller asked for, in order.
-    2. ``scan_modes/<mode>`` (always).
-    3. ``tooling/agent_browser`` (always — every agent has shell + the
-       agent-browser CLI).
-    4. ``tooling/python`` (always — Python runs through ``exec_command``;
-       sandbox scripts can import ``caido_api`` for Caido automation).
-    5. ``coordination/root_agent`` for the root agent only — orchestration
-       guidance for delegating to specialist subagents.
-    6. Whitebox-specific skills if applicable.
-    """
-    ordered: list[str] = list(requested or [])
-    ordered.append(f"scan_modes/{scan_mode}")
-    ordered.append("tooling/agent_browser")
-    ordered.append("tooling/python")
-    if is_root:
-        ordered.append("coordination/root_agent")
-    if is_whitebox:
-        ordered.append("coordination/source_aware_whitebox")
-        ordered.append("custom/source_aware_sast")
-
-    deduped: list[str] = []
-    seen: set[str] = set()
-    for skill in ordered:
-        if skill and skill not in seen:
-            deduped.append(skill)
-            seen.add(skill)
-    return deduped
-
-
-def render_system_prompt(
-    *,
-    skills: list[str] | None = None,
-    scan_mode: str = "deep",
-    is_whitebox: bool = False,
-    is_root: bool = False,
-    interactive: bool = False,
-    system_prompt_context: dict[str, Any] | None = None,
-) -> str:
-    """Render the system prompt. Returns empty string on template failure."""
-    try:
-        prompt_dir = get_strix_resource_path("agents", _PROMPT_DIRNAME)
-        loader_dirs = [prompt_dir, *skill_search_dirs()]
-        env = Environment(
-            loader=FileSystemLoader(loader_dirs),
-            autoescape=select_autoescape(
-                enabled_extensions=(),
-                default_for_string=False,
-            ),
-        )
-
-        skills_to_load = _resolve_skills(
-            requested=skills,
-            scan_mode=scan_mode,
-            is_whitebox=is_whitebox,
-            is_root=is_root,
-        )
-        skill_content = load_skills(skills_to_load)
-        env.globals["get_skill"] = lambda name: skill_content.get(name, "")
-
-        rendered = env.get_template("system_prompt.jinja").render(
-            loaded_skill_names=list(skill_content.keys()),
-            available_skills=get_available_skills(),
-            interactive=interactive,
-            system_prompt_context=system_prompt_context or {},
-            **skill_content,
-        )
-    except Exception:
-        logger.exception("render_system_prompt failed; returning empty prompt")
-        return ""
-    else:
-        logger.debug(
-            "render_system_prompt: scan_mode=%s root=%s whitebox=%s skills=%d prompt_len=%d",
-            scan_mode,
-            is_root,
-            is_whitebox,
-            len(skill_content),
-            len(rendered),
-        )
-        return str(rendered)

strix/agents/state.py

@@ -0,0 +1,172 @@
+import uuid
+from datetime import UTC, datetime
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+def _generate_agent_id() -> str:
+    return f"agent_{uuid.uuid4().hex[:8]}"
+
+
+class AgentState(BaseModel):
+    agent_id: str = Field(default_factory=_generate_agent_id)
+    agent_name: str = "Strix Agent"
+    parent_id: str | None = None
+    sandbox_id: str | None = None
+    sandbox_token: str | None = None
+    sandbox_info: dict[str, Any] | None = None
+
+    task: str = ""
+    iteration: int = 0
+    max_iterations: int = 300
+    completed: bool = False
+    stop_requested: bool = False
+    waiting_for_input: bool = False
+    llm_failed: bool = False
+    waiting_start_time: datetime | None = None
+    waiting_timeout: int = 600
+    final_result: dict[str, Any] | None = None
+    max_iterations_warning_sent: bool = False
+
+    messages: list[dict[str, Any]] = Field(default_factory=list)
+    context: dict[str, Any] = Field(default_factory=dict)
+
+    start_time: str = Field(default_factory=lambda: datetime.now(UTC).isoformat())
+    last_updated: str = Field(default_factory=lambda: datetime.now(UTC).isoformat())
+
+    actions_taken: list[dict[str, Any]] = Field(default_factory=list)
+    observations: list[dict[str, Any]] = Field(default_factory=list)
+
+    errors: list[str] = Field(default_factory=list)
+
+    def increment_iteration(self) -> None:
+        self.iteration += 1
+        self.last_updated = datetime.now(UTC).isoformat()
+
+    def add_message(
+        self, role: str, content: Any, thinking_blocks: list[dict[str, Any]] | None = None
+    ) -> None:
+        message = {"role": role, "content": content}
+        if thinking_blocks:
+            message["thinking_blocks"] = thinking_blocks
+        self.messages.append(message)
+        self.last_updated = datetime.now(UTC).isoformat()
+
+    def add_action(self, action: dict[str, Any]) -> None:
+        self.actions_taken.append(
+            {
+                "iteration": self.iteration,
+                "timestamp": datetime.now(UTC).isoformat(),
+                "action": action,
+            }
+        )
+
+    def add_observation(self, observation: dict[str, Any]) -> None:
+        self.observations.append(
+            {
+                "iteration": self.iteration,
+                "timestamp": datetime.now(UTC).isoformat(),
+                "observation": observation,
+            }
+        )
+
+    def add_error(self, error: str) -> None:
+        self.errors.append(f"Iteration {self.iteration}: {error}")
+        self.last_updated = datetime.now(UTC).isoformat()
+
+    def update_context(self, key: str, value: Any) -> None:
+        self.context[key] = value
+        self.last_updated = datetime.now(UTC).isoformat()
+
+    def set_completed(self, final_result: dict[str, Any] | None = None) -> None:
+        self.completed = True
+        self.final_result = final_result
+        self.last_updated = datetime.now(UTC).isoformat()
+
+    def request_stop(self) -> None:
+        self.stop_requested = True
+        self.last_updated = datetime.now(UTC).isoformat()
+
+    def should_stop(self) -> bool:
+        return self.stop_requested or self.completed or self.has_reached_max_iterations()
+
+    def is_waiting_for_input(self) -> bool:
+        return self.waiting_for_input
+
+    def enter_waiting_state(self, llm_failed: bool = False) -> None:
+        self.waiting_for_input = True
+        self.waiting_start_time = datetime.now(UTC)
+        self.llm_failed = llm_failed
+        self.last_updated = datetime.now(UTC).isoformat()
+
+    def resume_from_waiting(self, new_task: str | None = None) -> None:
+        self.waiting_for_input = False
+        self.waiting_start_time = None
+        self.stop_requested = False
+        self.completed = False
+        self.llm_failed = False
+        if new_task:
+            self.task = new_task
+        self.last_updated = datetime.now(UTC).isoformat()
+
+    def has_reached_max_iterations(self) -> bool:
+        return self.iteration >= self.max_iterations
+
+    def is_approaching_max_iterations(self, threshold: float = 0.85) -> bool:
+        return self.iteration >= int(self.max_iterations * threshold)
+
+    def has_waiting_timeout(self) -> bool:
+        if self.waiting_timeout == 0:
+            return False
+
+        if not self.waiting_for_input or not self.waiting_start_time:
+            return False
+
+        if (
+            self.stop_requested
+            or self.llm_failed
+            or self.completed
+            or self.has_reached_max_iterations()
+        ):
+            return False
+
+        elapsed = (datetime.now(UTC) - self.waiting_start_time).total_seconds()
+        return elapsed > self.waiting_timeout
+
+    def has_empty_last_messages(self, count: int = 3) -> bool:
+        if len(self.messages) < count:
+            return False
+
+        last_messages = self.messages[-count:]
+
+        for message in last_messages:
+            content = message.get("content", "")
+            if isinstance(content, str) and content.strip():
+                return False
+
+        return True
+
+    def get_conversation_history(self) -> list[dict[str, Any]]:
+        return self.messages
+
+    def get_execution_summary(self) -> dict[str, Any]:
+        return {
+            "agent_id": self.agent_id,
+            "agent_name": self.agent_name,
+            "parent_id": self.parent_id,
+            "sandbox_id": self.sandbox_id,
+            "sandbox_info": self.sandbox_info,
+            "task": self.task,
+            "iteration": self.iteration,
+            "max_iterations": self.max_iterations,
+            "completed": self.completed,
+            "final_result": self.final_result,
+            "start_time": self.start_time,
+            "last_updated": self.last_updated,
+            "total_actions": len(self.actions_taken),
+            "total_observations": len(self.observations),
+            "total_errors": len(self.errors),
+            "has_errors": len(self.errors) > 0,
+            "max_iterations_reached": self.has_reached_max_iterations() and not self.completed,
+        }

strix/config/__init__.py

@@ -1,37 +1,12 @@
-"""Strix application settings.
-
-Public surface:
-
-- :class:`Settings` — composite model. Get via :func:`load_settings`.
-- :class:`LlmSettings`, :class:`RuntimeSettings`, :class:`TelemetrySettings`,
-  :class:`IntegrationSettings` — sub-models, attribute-accessed off
-  ``Settings``.
-- :func:`load_settings` — memoized resolve (env > JSON file > defaults).
-- :func:`apply_config_override` — switch the JSON source to a custom path.
-- :func:`persist_current` — write currently-set env vars to the active file.
-"""
-
-from strix.config.loader import (
-    apply_config_override,
-    load_settings,
-    persist_current,
-)
-from strix.config.settings import (
-    IntegrationSettings,
-    LlmSettings,
-    RuntimeSettings,
-    Settings,
-    TelemetrySettings,
+from strix.config.config import (
+    Config,
+    apply_saved_config,
+    save_current_config,
 )
 
 
 __all__ = [
-    "IntegrationSettings",
-    "LlmSettings",
-    "RuntimeSettings",
-    "Settings",
-    "TelemetrySettings",
-    "apply_config_override",
-    "load_settings",
-    "persist_current",
+    "Config",
+    "apply_saved_config",
+    "save_current_config",
 ]

strix/config/config.py

@@ -0,0 +1,215 @@
+import contextlib
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+
+STRIX_API_BASE = "https://models.strix.ai/api/v1"
+
+
+class Config:
+    """Configuration Manager for Strix."""
+
+    # LLM Configuration
+    strix_llm = None
+    llm_api_key = None
+    llm_api_base = None
+    openai_api_base = None
+    litellm_base_url = None
+    ollama_api_base = None
+    strix_reasoning_effort = "high"
+    strix_llm_max_retries = "5"
+    strix_memory_compressor_timeout = "30"
+    llm_timeout = "300"
+    _LLM_CANONICAL_NAMES = (
+        "strix_llm",
+        "llm_api_key",
+        "llm_api_base",
+        "openai_api_base",
+        "litellm_base_url",
+        "ollama_api_base",
+        "strix_reasoning_effort",
+        "strix_llm_max_retries",
+        "strix_memory_compressor_timeout",
+        "llm_timeout",
+    )
+
+    # Tool & Feature Configuration
+    perplexity_api_key = None
+    strix_disable_browser = "false"
+
+    # Runtime Configuration
+    strix_image = "ghcr.io/usestrix/strix-sandbox:0.1.13"
+    strix_runtime_backend = "docker"
+    strix_sandbox_execution_timeout = "120"
+    strix_sandbox_connect_timeout = "10"
+
+    # Telemetry
+    strix_telemetry = "1"
+    strix_otel_telemetry = None
+    strix_posthog_telemetry = None
+    traceloop_base_url = None
+    traceloop_api_key = None
+    traceloop_headers = None
+
+    # Config file override (set via --config CLI arg)
+    _config_file_override: Path | None = None
+
+    @classmethod
+    def _tracked_names(cls) -> list[str]:
+        return [
+            k
+            for k, v in vars(cls).items()
+            if not k.startswith("_") and k[0].islower() and (v is None or isinstance(v, str))
+        ]
+
+    @classmethod
+    def tracked_vars(cls) -> list[str]:
+        return [name.upper() for name in cls._tracked_names()]
+
+    @classmethod
+    def _llm_env_vars(cls) -> set[str]:
+        return {name.upper() for name in cls._LLM_CANONICAL_NAMES}
+
+    @classmethod
+    def _llm_env_changed(cls, saved_env: dict[str, Any]) -> bool:
+        for var_name in cls._llm_env_vars():
+            current = os.getenv(var_name)
+            if current is None:
+                continue
+            if saved_env.get(var_name) != current:
+                return True
+        return False
+
+    @classmethod
+    def get(cls, name: str) -> str | None:
+        env_name = name.upper()
+        default = getattr(cls, name, None)
+        return os.getenv(env_name, default)
+
+    @classmethod
+    def config_dir(cls) -> Path:
+        return Path.home() / ".strix"
+
+    @classmethod
+    def config_file(cls) -> Path:
+        if cls._config_file_override is not None:
+            return cls._config_file_override
+        return cls.config_dir() / "cli-config.json"
+
+    @classmethod
+    def load(cls) -> dict[str, Any]:
+        path = cls.config_file()
+        if not path.exists():
+            return {}
+        try:
+            with path.open("r", encoding="utf-8") as f:
+                data: dict[str, Any] = json.load(f)
+                return data
+        except (json.JSONDecodeError, OSError):
+            return {}
+
+    @classmethod
+    def save(cls, config: dict[str, Any]) -> bool:
+        try:
+            cls.config_dir().mkdir(parents=True, exist_ok=True)
+            config_path = cls.config_dir() / "cli-config.json"
+            with config_path.open("w", encoding="utf-8") as f:
+                json.dump(config, f, indent=2)
+        except OSError:
+            return False
+        with contextlib.suppress(OSError):
+            config_path.chmod(0o600)  # may fail on Windows
+        return True
+
+    @classmethod
+    def apply_saved(cls, force: bool = False) -> dict[str, str]:
+        saved = cls.load()
+        env_vars = saved.get("env", {})
+        if not isinstance(env_vars, dict):
+            env_vars = {}
+        cleared_vars = {
+            var_name
+            for var_name in cls.tracked_vars()
+            if var_name in os.environ and os.environ.get(var_name) == ""
+        }
+        if cleared_vars:
+            for var_name in cleared_vars:
+                env_vars.pop(var_name, None)
+            if cls._config_file_override is None:
+                cls.save({"env": env_vars})
+        if cls._llm_env_changed(env_vars):
+            for var_name in cls._llm_env_vars():
+                env_vars.pop(var_name, None)
+            if cls._config_file_override is None:
+                cls.save({"env": env_vars})
+        applied = {}
+
+        for var_name, var_value in env_vars.items():
+            if var_name in cls.tracked_vars() and (force or var_name not in os.environ):
+                os.environ[var_name] = var_value
+                applied[var_name] = var_value
+
+        return applied
+
+    @classmethod
+    def capture_current(cls) -> dict[str, Any]:
+        env_vars = {}
+        for var_name in cls.tracked_vars():
+            value = os.getenv(var_name)
+            if value:
+                env_vars[var_name] = value
+        return {"env": env_vars}
+
+    @classmethod
+    def save_current(cls) -> bool:
+        existing = cls.load().get("env", {})
+        merged = dict(existing)
+
+        for var_name in cls.tracked_vars():
+            value = os.getenv(var_name)
+            if value is None:
+                pass
+            elif value == "":
+                merged.pop(var_name, None)
+            else:
+                merged[var_name] = value
+
+        return cls.save({"env": merged})
+
+
+def apply_saved_config(force: bool = False) -> dict[str, str]:
+    return Config.apply_saved(force=force)
+
+
+def save_current_config() -> bool:
+    return Config.save_current()
+
+
+def resolve_llm_config() -> tuple[str | None, str | None, str | None]:
+    """Resolve LLM model, api_key, and api_base based on STRIX_LLM prefix.
+
+    Returns:
+        tuple: (model_name, api_key, api_base)
+        - model_name: Original model name (strix/ prefix preserved for display)
+        - api_key: LLM API key
+        - api_base: API base URL (auto-set to STRIX_API_BASE for strix/ models)
+    """
+    model = Config.get("strix_llm")
+    if not model:
+        return None, None, None
+
+    api_key = Config.get("llm_api_key")
+
+    if model.startswith("strix/"):
+        api_base: str | None = STRIX_API_BASE
+    else:
+        api_base = (
+            Config.get("llm_api_base")
+            or Config.get("openai_api_base")
+            or Config.get("litellm_base_url")
+            or Config.get("ollama_api_base")
+        )
+
+    return model, api_key, api_base

strix/config/loader.py

@@ -1,127 +0,0 @@
-"""Settings loader, override switch, and disk persistence."""
-
-from __future__ import annotations
-
-import contextlib
-import json
-import logging
-import os
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-from pydantic import AliasChoices, BaseModel
-
-from strix.config.settings import Settings
-
-
-if TYPE_CHECKING:
-    from pydantic.fields import FieldInfo
-
-
-logger = logging.getLogger(__name__)
-
-
-_DEFAULT_PATH: Path = Path.home() / ".strix" / "cli-config.json"
-_override: Path | None = None
-_cached: Settings | None = None
-
-
-def load_settings() -> Settings:
-    """Resolve settings from env + JSON file + defaults. Memoized.
-
-    Precedence: env vars win, then the JSON file, then field defaults.
-    """
-    global _cached  # noqa: PLW0603
-    if _cached is None:
-        source_path = _override or _DEFAULT_PATH
-        init_kwargs: dict[str, Any] = _read_json_overrides(source_path)
-        _cached = Settings(**init_kwargs)
-        logger.debug(
-            "load_settings: resolved (override=%s, file_used=%s, json_keys=%d)",
-            _override is not None,
-            source_path.exists(),
-            sum(len(v) for v in init_kwargs.values()),
-        )
-    return _cached
-
-
-def apply_config_override(path: Path) -> None:
-    """Switch the JSON source to ``path`` and invalidate the cache."""
-    global _override, _cached  # noqa: PLW0603
-    _override = path
-    _cached = None
-    logger.info("config override applied: %s", path)
-
-
-def persist_current() -> None:
-    """Write currently-set env vars to the active config file (0o600)."""
-    s = load_settings()
-    target = _override or _DEFAULT_PATH
-    target.parent.mkdir(parents=True, exist_ok=True)
-
-    env_block: dict[str, str] = {}
-    for sub_name in s.model_fields:
-        sub_model = getattr(s, sub_name)
-        if not isinstance(sub_model, BaseModel):
-            continue
-        for finfo in type(sub_model).model_fields.values():
-            for alias in _aliases_for(finfo):
-                value = os.environ.get(alias.upper())
-                if value:
-                    env_block[alias.upper()] = value
-                    break
-
-    target.write_text(json.dumps({"env": env_block}, indent=2), encoding="utf-8")
-    with contextlib.suppress(OSError):
-        target.chmod(0o600)
-
-
-def _aliases_for(finfo: FieldInfo) -> list[str]:
-    """Collect every env-var name that should populate ``finfo``."""
-    aliases: list[str] = []
-    if finfo.alias:
-        aliases.append(finfo.alias)
-    va = finfo.validation_alias
-    if isinstance(va, AliasChoices):
-        aliases.extend(c for c in va.choices if isinstance(c, str))
-    elif isinstance(va, str):
-        aliases.append(va)
-    return aliases
-
-
-def _read_json_overrides(path: Path) -> dict[str, dict[str, Any]]:
-    """Read ``{"env": {...}}`` from ``path`` and remap to nested kwargs.
-
-    Only includes keys whose env var is NOT already set, so env always
-    wins over the persisted file.
-    """
-    if not path.exists():
-        return {}
-    try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-    except (json.JSONDecodeError, OSError):
-        return {}
-    env_block = data.get("env", {}) if isinstance(data, dict) else {}
-    if not isinstance(env_block, dict):
-        return {}
-
-    env_block_upper = {str(k).upper(): v for k, v in env_block.items()}
-    env_present = {k.upper() for k in os.environ}
-
-    nested: dict[str, dict[str, Any]] = {}
-    for sub_name, sub_finfo in Settings.model_fields.items():
-        sub_cls = sub_finfo.annotation
-        if not (isinstance(sub_cls, type) and issubclass(sub_cls, BaseModel)):
-            continue
-        sub_data: dict[str, Any] = {}
-        for fname, finfo in sub_cls.model_fields.items():
-            aliases = [alias.upper() for alias in _aliases_for(finfo)]
-            if any(alias in env_present for alias in aliases):
-                continue  # env wins under some alias; skip the JSON file for this field
-            for alias in aliases:
-                if alias in env_block_upper:
-                    sub_data[fname] = env_block_upper[alias]
-                    break
-        if sub_data:
-            nested[sub_name] = sub_data
-    return nested

strix/config/models.py

@@ -1,166 +0,0 @@
-"""SDK model configuration helpers."""
-
-from __future__ import annotations
-
-import os
-from typing import TYPE_CHECKING
-
-from agents import set_default_openai_api, set_default_openai_key, set_tracing_disabled
-from agents.models.multi_provider import MultiProvider
-from agents.retry import (
-    ModelRetryBackoffSettings,
-    ModelRetrySettings,
-    retry_policies,
-)
-
-
-if TYPE_CHECKING:
-    from agents.models.interface import ModelProvider
-
-    from strix.config.settings import Settings
-
-
-class StrixProvider(MultiProvider):
-    """Route any non-OpenAI prefix through LiteLLM with the prefix preserved,
-    so users type ``deepseek/deepseek-chat`` rather than
-    ``litellm/deepseek/deepseek-chat``.
-    """
-
-    def _resolve_prefixed_model(
-        self,
-        *,
-        original_model_name: str,
-        prefix: str,
-        stripped_model_name: str | None,
-    ) -> tuple[ModelProvider, str | None]:
-        if prefix in {"openai", "litellm", "any-llm"}:
-            return super()._resolve_prefixed_model(
-                original_model_name=original_model_name,
-                prefix=prefix,
-                stripped_model_name=stripped_model_name,
-            )
-        if prefix == "ollama" and stripped_model_name:
-            return self._get_fallback_provider("litellm"), f"ollama_chat/{stripped_model_name}"
-        return self._get_fallback_provider("litellm"), original_model_name
-
-
-DEFAULT_MODEL_RETRY = ModelRetrySettings(
-    max_retries=5,
-    backoff=ModelRetryBackoffSettings(
-        initial_delay=2.0,
-        max_delay=90.0,
-        multiplier=2.0,
-        jitter=False,
-    ),
-    policy=retry_policies.any(
-        retry_policies.provider_suggested(),
-        retry_policies.network_error(),
-        retry_policies.http_status((429, 500, 502, 503, 504)),
-    ),
-)
-
-
-def configure_sdk_model_defaults(settings: Settings) -> None:
-    """Apply Strix config to SDK-native defaults."""
-    llm = settings.llm
-    set_tracing_disabled(True)
-    _configure_litellm_compatibility()
-    if llm.api_key:
-        set_default_openai_key(llm.api_key, use_for_tracing=False)
-        _configure_litellm_default("api_key", llm.api_key)
-        _mirror_api_key_to_provider_env(llm.model, llm.api_key)
-    if llm.api_base:
-        os.environ["OPENAI_BASE_URL"] = llm.api_base
-        _configure_litellm_default("api_base", llm.api_base)
-        set_default_openai_api("chat_completions")
-    else:
-        set_default_openai_api("responses")
-
-
-def _mirror_api_key_to_provider_env(model_name: str | None, api_key: str) -> None:
-    if not model_name:
-        return
-    import litellm
-
-    name = model_name.strip()
-    for prefix in ("litellm/", "any-llm/"):
-        if name.lower().startswith(prefix):
-            name = name[len(prefix) :]
-            break
-    try:
-        report = litellm.validate_environment(model=name.lower())
-    except Exception:  # noqa: BLE001
-        return
-    for env_key in report.get("missing_keys") or []:
-        if env_key.endswith("_API_KEY"):
-            os.environ.setdefault(env_key, api_key)
-
-
-def _configure_litellm_compatibility() -> None:
-    """Apply LiteLLM compatibility, privacy, and callback settings."""
-    import litellm
-
-    litellm.drop_params = True
-    litellm.modify_params = True
-    litellm.turn_off_message_logging = True
-    # Strix uses LiteLLM's success callback to capture provider-reported cost.
-    # Disabling streaming logging also disables that callback for streamed calls.
-    litellm.disable_streaming_logging = False
-    litellm.suppress_debug_info = True
-
-    _register_litellm_cost_callback()
-
-
-def _register_litellm_cost_callback() -> None:
-    import litellm
-
-    from strix.report.state import litellm_cost_callback
-
-    for bucket_name in ("success_callback", "_async_success_callback"):
-        bucket = getattr(litellm, bucket_name, None)
-        if not isinstance(bucket, list):
-            continue
-        if litellm_cost_callback in bucket:
-            continue
-        bucket.append(litellm_cost_callback)
-
-
-def _configure_litellm_default(name: str, value: str) -> None:
-    """Set LiteLLM's module-level defaults without adding a provider wrapper."""
-    import litellm
-
-    setattr(litellm, name, value)
-
-
-def uses_chat_completions_tool_schema(model_name: str, settings: Settings) -> bool:
-    """Return whether the resolved SDK route can only receive JSON function tools."""
-    model = model_name.strip().lower()
-    if "/" in model and not model.startswith("openai/"):
-        return True
-    if settings.llm.api_base:
-        return True
-    return not model_supports_reasoning(model_name)
-
-
-def model_supports_reasoning(model_name: str) -> bool:
-    import litellm
-
-    name = model_name.strip().lower()
-    for prefix in ("litellm/", "any-llm/", "openai/"):
-        if name.startswith(prefix):
-            name = name[len(prefix) :]
-            break
-    entry = litellm.model_cost.get(name)
-    if entry is None and "/" in name:
-        entry = litellm.model_cost.get(name.rsplit("/", 1)[1])
-    return bool(entry and entry.get("supports_reasoning"))
-
-
-def is_known_openai_bare_model(model_name: str) -> bool:
-    import litellm
-
-    name = model_name.strip().lower()
-    if not name or "/" in name:
-        return False
-    entry = litellm.model_cost.get(name)
-    return bool(entry and entry.get("litellm_provider") == "openai")

strix/config/settings.py

@@ -1,79 +0,0 @@
-"""Strix application settings — pydantic-settings powered."""
-
-from __future__ import annotations
-
-from typing import Literal
-
-from pydantic import AliasChoices, Field
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-ReasoningEffort = Literal["none", "minimal", "low", "medium", "high", "xhigh"]
-
-_BASE_CONFIG = SettingsConfigDict(
-    case_sensitive=False,
-    populate_by_name=True,
-    extra="ignore",
-)
-
-
-class LlmSettings(BaseSettings):
-    model_config = _BASE_CONFIG
-
-    model: str | None = Field(default=None, alias="STRIX_LLM")
-    api_key: str | None = Field(
-        default=None,
-        validation_alias=AliasChoices("LLM_API_KEY", "OPENAI_API_KEY"),
-    )
-    api_base: str | None = Field(
-        default=None,
-        validation_alias=AliasChoices(
-            "LLM_API_BASE",
-            "OPENAI_API_BASE",
-            "OPENAI_BASE_URL",
-            "LITELLM_BASE_URL",
-            "OLLAMA_API_BASE",
-        ),
-    )
-    reasoning_effort: ReasoningEffort = Field(default="high", alias="STRIX_REASONING_EFFORT")
-    force_required_tool_choice: bool = Field(
-        default=False,
-        alias="STRIX_FORCE_REQUIRED_TOOL_CHOICE",
-    )
-    timeout: int = Field(default=300, alias="LLM_TIMEOUT")
-
-
-class RuntimeSettings(BaseSettings):
-    model_config = _BASE_CONFIG
-
-    image: str = Field(
-        default="ghcr.io/usestrix/strix-sandbox:1.0.0",
-        alias="STRIX_IMAGE",
-    )
-    backend: str = Field(default="docker", alias="STRIX_RUNTIME_BACKEND")
-    # Hard cap on a local target's size before we refuse to stream it into the
-    # sandbox file-by-file (the SDK copies every file individually, which stalls
-    # on large repos). Above this, the user must bind-mount via ``--mount``.
-    # Set to 0 (or less) to disable the pre-flight check entirely.
-    max_local_copy_mb: int = Field(default=1024, alias="STRIX_MAX_LOCAL_COPY_MB")
-
-
-class TelemetrySettings(BaseSettings):
-    model_config = _BASE_CONFIG
-
-    enabled: bool = Field(default=True, alias="STRIX_TELEMETRY")
-
-
-class IntegrationSettings(BaseSettings):
-    model_config = _BASE_CONFIG
-
-    perplexity_api_key: str | None = Field(default=None, alias="PERPLEXITY_API_KEY")
-
-
-class Settings(BaseSettings):
-    model_config = _BASE_CONFIG
-
-    llm: LlmSettings = Field(default_factory=LlmSettings)
-    runtime: RuntimeSettings = Field(default_factory=RuntimeSettings)
-    telemetry: TelemetrySettings = Field(default_factory=TelemetrySettings)
-    integrations: IntegrationSettings = Field(default_factory=IntegrationSettings)

strix/core/__init__.py

@@ -1 +0,0 @@
-"""Strix scan runtime core."""

strix/core/agents.py

@@ -1,323 +0,0 @@
-"""SDK-native state for Strix's addressable agent graph."""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-import tempfile
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, cast
-
-
-if TYPE_CHECKING:
-    from agents.items import TResponseInputItem
-    from agents.memory import Session
-
-
-logger = logging.getLogger(__name__)
-
-Status = Literal["running", "waiting", "completed", "stopped", "crashed", "failed"]
-
-
-@dataclass(slots=True)
-class AgentRuntime:
-    session: Session | None = None
-    task: asyncio.Task[Any] | None = None
-    stream: Any | None = None
-    interrupt_on_message: bool = False
-    wake: asyncio.Event = field(default_factory=asyncio.Event)
-
-
-class AgentCoordinator:
-    """Single owner for graph state, SDK runtimes, messages, and resume snapshots."""
-
-    def __init__(self) -> None:
-        self.statuses: dict[str, Status] = {}
-        self.parent_of: dict[str, str | None] = {}
-        self.names: dict[str, str] = {}
-        self.metadata: dict[str, dict[str, Any]] = {}
-        self.pending_counts: dict[str, int] = {}
-        self.runtimes: dict[str, AgentRuntime] = {}
-        self._lock = asyncio.Lock()
-        self._snapshot_path: Path | None = None
-        self.is_shutting_down = False
-        self._budget_stopped = False
-
-    def set_snapshot_path(self, path: Path) -> None:
-        self._snapshot_path = path
-
-    def mark_shutting_down(self) -> None:
-        self.is_shutting_down = True
-
-    @property
-    def budget_stopped(self) -> bool:
-        return self._budget_stopped
-
-    async def trigger_budget_stop(self) -> None:
-        """Signal a scan-wide budget stop and wake every parked agent so it exits."""
-        async with self._lock:
-            self._budget_stopped = True
-            for runtime in self.runtimes.values():
-                runtime.wake.set()
-
-    async def register(
-        self,
-        agent_id: str,
-        name: str,
-        parent_id: str | None,
-        *,
-        task: str | None = None,
-        skills: list[str] | None = None,
-    ) -> None:
-        async with self._lock:
-            self.statuses[agent_id] = "running"
-            self.parent_of[agent_id] = parent_id
-            self.names[agent_id] = name
-            self.pending_counts.setdefault(agent_id, 0)
-            self.metadata[agent_id] = {
-                "task": task or "",
-                "skills": list(skills or []),
-            }
-            self.runtimes.setdefault(agent_id, AgentRuntime())
-        logger.info("agent.register %s (%s) parent=%s", agent_id, name, parent_id or "-")
-        await self._maybe_snapshot()
-
-    async def attach_runtime(
-        self,
-        agent_id: str,
-        *,
-        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())
-            if session is not None:
-                runtime.session = session
-            if task is not None:
-                runtime.task = task
-            if interrupt_on_message is not None:
-                runtime.interrupt_on_message = interrupt_on_message
-
-    async def mark_running(self, agent_id: str) -> None:
-        async with self._lock:
-            if agent_id in self.statuses:
-                self.statuses[agent_id] = "running"
-        await self._maybe_snapshot()
-
-    async def park_waiting(self, agent_id: str) -> None:
-        await self.set_status(agent_id, "waiting")
-
-    async def set_status(self, agent_id: str, status: Status | str) -> None:
-        async with self._lock:
-            if agent_id not in self.statuses:
-                return
-            self.statuses[agent_id] = status  # type: ignore[assignment]
-            runtime = self.runtimes.setdefault(agent_id, AgentRuntime())
-            runtime.wake.set()
-        logger.info("agent.status %s=%s", agent_id, status)
-        await self._maybe_snapshot()
-
-    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."""
-        async with self._lock:
-            if target_agent_id not in self.statuses:
-                logger.debug("agent.send dropped unknown target=%s", target_agent_id)
-                return False
-            runtime = self.runtimes.setdefault(target_agent_id, AgentRuntime())
-            session = runtime.session
-            stream = runtime.stream
-            interrupt = runtime.interrupt_on_message
-        if session is None:
-            logger.warning(
-                "agent.send dropped target=%s because its SDK session is not attached",
-                target_agent_id,
-            )
-            return False
-        try:
-            await session.add_items([self._message_to_session_item(message)])
-        except Exception:
-            logger.exception(
-                "agent.send failed to append to SDK session target=%s",
-                target_agent_id,
-            )
-            return False
-        async with self._lock:
-            self.pending_counts[target_agent_id] = self.pending_counts.get(target_agent_id, 0) + 1
-            self.runtimes.setdefault(target_agent_id, AgentRuntime()).wake.set()
-        if stream is not None and interrupt:
-            stream.cancel(mode="immediate")
-        await self._maybe_snapshot()
-        return True
-
-    async def wait_for_message(self, agent_id: str) -> None:
-        while True:
-            async with self._lock:
-                if self._budget_stopped or self.pending_counts.get(agent_id, 0) > 0:
-                    return
-                wake = self.runtimes.setdefault(agent_id, AgentRuntime()).wake
-                wake.clear()
-            await wake.wait()
-
-    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
-            session = self.runtimes.get(agent_id, AgentRuntime()).session
-        if count <= 0:
-            return 0, []
-        await self._maybe_snapshot()
-        if not include_items or session is None:
-            return count, []
-        items = await session.get_items()
-        return count, list(items[-count:])
-
-    async def request_stop(self, agent_id: str) -> None:
-        async with self._lock:
-            if agent_id not in self.statuses:
-                return
-            self.statuses[agent_id] = "stopped"
-            runtime = self.runtimes.setdefault(agent_id, AgentRuntime())
-            runtime.wake.set()
-            stream = runtime.stream
-        if stream is not None:
-            stream.cancel(mode="after_turn")
-        await self._maybe_snapshot()
-
-    async def cancel_descendants(self, agent_id: str) -> None:
-        tasks = []
-        async with self._lock:
-            for aid in reversed(self._subtree_order_locked(agent_id)):
-                task = self.runtimes.get(aid, AgentRuntime()).task
-                if task is not None and not task.done():
-                    tasks.append(task)
-        for task in tasks:
-            task.cancel()
-        if tasks:
-            await asyncio.gather(*tasks, return_exceptions=True)
-
-    async def cancel_descendants_graceful(self, agent_id: str) -> None:
-        async with self._lock:
-            order = self._subtree_order_locked(agent_id)
-        for aid in reversed(order):
-            await self.request_stop(aid)
-        await self._maybe_snapshot()
-
-    async def attach_stream(
-        self,
-        agent_id: str,
-        stream: Any,
-    ) -> None:
-        async with self._lock:
-            self.runtimes.setdefault(agent_id, AgentRuntime()).stream = stream
-
-    async def detach_stream(
-        self,
-        agent_id: str,
-        stream: Any,
-    ) -> None:
-        async with self._lock:
-            runtime = self.runtimes.setdefault(agent_id, AgentRuntime())
-            if runtime.stream is stream:
-                runtime.stream = None
-
-    async def active_agents_except(self, agent_id: str) -> list[dict[str, Any]]:
-        async with self._lock:
-            return [
-                {
-                    "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 {"running", "waiting"}
-            ]
-
-    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)
-
-    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 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 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]
-        order: list[str] = []
-        while queue:
-            aid = queue.pop()
-            order.append(aid)
-            queue.extend(child for child, parent in self.parent_of.items() if parent == aid)
-        return order
-
-    async def snapshot(self) -> dict[str, Any]:
-        async with self._lock:
-            return {
-                "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),
-            }
-
-    async def restore(self, snap: dict[str, Any]) -> None:
-        async with self._lock:
-            self.statuses = dict(snap.get("statuses", {}))
-            self.parent_of = dict(snap.get("parent_of", {}))
-            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", {}))
-            for aid in self.statuses:
-                self.runtimes.setdefault(aid, AgentRuntime())
-
-    async def _maybe_snapshot(self) -> None:
-        path = self._snapshot_path
-        if path is None:
-            return
-        try:
-            data = await self.snapshot()
-            payload = json.dumps(data, ensure_ascii=False, default=str)
-            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)
-        except Exception:
-            logger.exception("coordinator snapshot to %s failed", path)
-
-
-def coordinator_from_context(ctx: dict[str, Any]) -> AgentCoordinator | None:
-    coordinator = ctx.get("coordinator")
-    return coordinator if isinstance(coordinator, AgentCoordinator) else None

strix/core/execution.py

@@ -1,575 +0,0 @@
-"""Execution loop for addressable SDK-backed Strix agents."""
-
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import logging
-import uuid
-from collections.abc import Callable
-from typing import TYPE_CHECKING, Any, cast
-
-from agents import RunConfig, Runner
-from agents.exceptions import AgentsException, MaxTurnsExceeded, UserError
-from agents.sandbox.errors import ExecTransportError
-from docker import errors as docker_errors  # type: ignore[import-untyped, unused-ignore]
-from openai import APIError
-
-from strix.core.hooks import BudgetExceededError
-from strix.core.inputs import child_initial_input
-from strix.core.sessions import open_agent_session, strip_all_images_from_session
-
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-    from agents.items import TResponseInputItem
-    from agents.lifecycle import RunHooks
-    from agents.memory import Session, SQLiteSession
-    from agents.result import RunResultBase
-
-    from strix.core.agents import AgentCoordinator, Status
-
-
-logger = logging.getLogger(__name__)
-
-StreamEventSink = Callable[[str, Any], None]
-
-_INPUT_REJECTION_CODES = frozenset({400, 404, 422})
-
-
-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,
-    event_sink: StreamEventSink | None = None,
-    hooks: RunHooks[dict[str, Any]] | None = None,
-) -> RunResultBase | None:
-    await coordinator.attach_runtime(
-        agent_id,
-        session=session,
-        interrupt_on_message=interactive,
-    )
-    result: RunResultBase | None = None
-
-    if not (start_parked and interactive):
-        if 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,
-                event_sink=event_sink,
-                hooks=hooks,
-            )
-        else:
-            result = await _run_noninteractive_until_lifecycle(
-                agent,
-                coordinator,
-                agent_id,
-                initial_input=initial_input,
-                run_config=run_config,
-                context=context,
-                max_turns=max_turns,
-                session=session,
-                event_sink=event_sink,
-                hooks=hooks,
-            )
-
-    if not interactive:
-        return result
-
-    while True:
-        try:
-            await coordinator.wait_for_message(agent_id)
-        except asyncio.CancelledError:
-            return result
-
-        if coordinator.budget_stopped:
-            await coordinator.set_status(agent_id, "stopped")
-            raise BudgetExceededError("scan budget reached")
-
-        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,
-            event_sink=event_sink,
-            hooks=hooks,
-        )
-
-
-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],
-    event_sink: StreamEventSink | None = None,
-    hooks: RunHooks[dict[str, Any]] | None = None,
-) -> 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,
-        ),
-        event_sink=event_sink,
-        hooks=hooks,
-    )
-
-    return {
-        "success": True,
-        "agent_id": child_id,
-        "name": name,
-        "parent_id": parent_id,
-        "message": f"Spawned '{name}' ({child_id}) running in parallel.",
-    }
-
-
-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,
-    event_sink: StreamEventSink | None = None,
-    hooks: RunHooks[dict[str, Any]] | None = None,
-) -> None:
-    async with coordinator._lock:
-        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,
-                event_sink=event_sink,
-                hooks=hooks,
-            )
-            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")
-
-
-async def _run_noninteractive_until_lifecycle(
-    agent: Any,
-    coordinator: AgentCoordinator,
-    agent_id: str,
-    *,
-    initial_input: Any,
-    run_config: RunConfig,
-    context: dict[str, Any],
-    max_turns: int,
-    session: Session | None,
-    event_sink: StreamEventSink | None,
-    hooks: RunHooks[dict[str, Any]] | None,
-) -> RunResultBase | None:
-    """Non-chat mode keeps running until finish_scan / agent_finish settles status."""
-    result: RunResultBase | None = None
-    input_data: Any = initial_input
-    invalid_final_outputs = 0
-    invalid_final_output_limit = max(1, max_turns)
-
-    while True:
-        if coordinator.budget_stopped:
-            await coordinator.set_status(agent_id, "stopped")
-            raise BudgetExceededError("scan budget reached")
-
-        result = await _run_cycle(
-            agent,
-            coordinator,
-            agent_id,
-            input_data=input_data,
-            run_config=run_config,
-            context=context,
-            max_turns=max_turns,
-            session=session,
-            interactive=False,
-            event_sink=event_sink,
-            hooks=hooks,
-        )
-
-        status = await _agent_status(coordinator, agent_id)
-        if status != "running":
-            return result
-
-        invalid_final_outputs += 1
-        logger.warning(
-            "agent %s produced non-lifecycle final output in non-interactive mode; "
-            "forcing tool continuation (%d/%d): %s",
-            agent_id,
-            invalid_final_outputs,
-            invalid_final_output_limit,
-            _final_output_preview(result),
-        )
-
-        if invalid_final_outputs >= invalid_final_output_limit:
-            await coordinator.set_status(agent_id, "crashed")
-            await _notify_parent_on_crash(coordinator, agent_id, "crashed")
-            raise MaxTurnsExceeded(
-                "Agent exhausted non-interactive recovery attempts without calling "
-                "finish_scan or agent_finish."
-            )
-
-        input_data = await _append_noninteractive_tool_required_message(
-            session=session,
-            context=context,
-            attempt=invalid_final_outputs,
-            limit=invalid_final_output_limit,
-        )
-
-
-async def _run_cycle(  # noqa: PLR0912, PLR0915
-    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,
-    event_sink: StreamEventSink | None,
-    hooks: RunHooks[dict[str, Any]] | None,
-) -> RunResultBase | None:
-    image_strips = 0
-    while True:
-        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,
-                hooks=hooks,
-            )
-            await coordinator.attach_stream(agent_id, stream)
-            try:
-                try:
-                    async for event in stream.stream_events():
-                        if event_sink is not None:
-                            try:
-                                event_sink(agent_id, event)
-                            except Exception:
-                                logger.exception("stream event sink failed for %s", agent_id)
-                    if stream.run_loop_exception is not None:
-                        raise stream.run_loop_exception
-                except BudgetExceededError:
-                    # A RuntimeError subclass: re-raise explicitly so it is never
-                    # mistaken for the LiteLLM "after shutdown" race below.
-                    raise
-                except RuntimeError as stream_exc:
-                    if "after shutdown" not in str(stream_exc):
-                        raise
-                    logger.warning(
-                        "Ignoring LiteLLM end-of-stream shutdown race for %s",
-                        agent_id,
-                    )
-                except (ExecTransportError, docker_errors.NotFound):
-                    if not coordinator.is_shutting_down:
-                        raise
-                    logger.warning(
-                        "Ignoring sandbox container error during teardown for %s",
-                        agent_id,
-                        exc_info=True,
-                    )
-            finally:
-                await coordinator.detach_stream(agent_id, stream)
-        except BudgetExceededError as exc:
-            logger.info(
-                "agent %s reached the scan budget limit; stopping the scan: %s", agent_id, exc
-            )
-            await coordinator.set_status(agent_id, "stopped")
-            await coordinator.trigger_budget_stop()
-            raise
-        except Exception as exc:
-            if (
-                image_strips < 3
-                and session is not None
-                and getattr(exc, "status_code", None) in _INPUT_REJECTION_CODES
-            ):
-                try:
-                    stripped = await strip_all_images_from_session(session)
-                except Exception:
-                    logger.exception("image-strip recovery failed for %s", agent_id)
-                    stripped = False
-                if stripped:
-                    image_strips += 1
-                    logger.info(
-                        "Stripped images from %s session after rejection; retrying (%d)",
-                        agent_id,
-                        image_strips,
-                    )
-                    input_data = []
-                    continue
-            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)
-            if context.get("parent_id") is None and status in {"failed", "crashed"}:
-                raise
-            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
-
-    if not interactive:
-        return
-
-    await coordinator.set_status(agent_id, "waiting")
-
-
-async def _agent_status(coordinator: AgentCoordinator, agent_id: str) -> Status | None:
-    async with coordinator._lock:
-        return coordinator.statuses.get(agent_id)
-
-
-def _final_output_preview(result: RunResultBase | None) -> str:
-    final_output = getattr(result, "final_output", None)
-    if final_output is None:
-        return "<none>"
-    text = str(final_output).replace("\n", " ").strip()
-    if not text:
-        return "<empty>"
-    return text[:300]
-
-
-async def _append_noninteractive_tool_required_message(
-    *,
-    session: Session | None,
-    context: dict[str, Any],
-    attempt: int,
-    limit: int,
-) -> list[dict[str, str]]:
-    finish_tool = "finish_scan" if context.get("parent_id") is None else "agent_finish"
-    message = (
-        "Your previous response ended the autonomous Strix run without a lifecycle tool call. "
-        "That is invalid in non-interactive mode; plain text final answers are ignored. "
-        "Continue immediately and call exactly one tool. "
-        f"If your work is complete, call {finish_tool}. "
-        "If you are blocked waiting for another agent, call wait_for_message. "
-        "Otherwise use the appropriate execution or planning tool. "
-        f"This is recovery attempt {attempt}/{limit}."
-    )
-    item = {"role": "user", "content": message}
-    if session is None:
-        return [item]
-
-    await session.add_items([cast("TResponseInputItem", item)])
-    return []
-
-
-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 _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,
-    event_sink: StreamEventSink | None = None,
-    hooks: RunHooks[dict[str, Any]] | None = None,
-) -> 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
-
-    async def _child_loop() -> None:
-        # A budget stop is a clean scan-wide shutdown, not a child failure: the
-        # child's status and parent notification are already settled in
-        # ``_run_cycle``. Swallow it here so the detached task does not surface a
-        # spurious "Task exception was never retrieved" warning. The root agent
-        # hits the same limit on its next call and tears the scan down.
-        try:
-            await 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,
-                event_sink=event_sink,
-                hooks=hooks,
-            )
-        except BudgetExceededError:
-            logger.info("child %s stopped after reaching the scan budget limit", child_id)
-
-    task_handle = asyncio.create_task(_child_loop(), name=f"agent-{name}-{child_id}")
-    await coordinator.attach_runtime(child_id, task=task_handle)

strix/core/hooks.py

@@ -1,69 +0,0 @@
-"""SDK run hooks used by Strix orchestration."""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Any
-
-from agents.lifecycle import RunHooks
-
-from strix.report.state import get_global_report_state
-
-
-if TYPE_CHECKING:
-    from agents import RunContextWrapper
-    from agents.agent import Agent
-    from agents.items import ModelResponse
-
-
-logger = logging.getLogger(__name__)
-
-
-class BudgetExceededError(RuntimeError):
-    """Raised when the accumulated LLM cost reaches the configured budget."""
-
-
-class ReportUsageHooks(RunHooks[dict[str, Any]]):
-    """Persist SDK-native usage after every model response."""
-
-    def __init__(self, *, model: str, max_budget_usd: float | None = None) -> None:
-        import math
-        if max_budget_usd is not None and (not math.isfinite(max_budget_usd) or max_budget_usd <= 0):
-            raise ValueError("max_budget_usd must be a finite number greater than 0")
-        self._model = model
-        self._max_budget_usd = max_budget_usd
-
-    async def on_llm_end(
-        self,
-        context: RunContextWrapper[dict[str, Any]],
-        agent: Agent[dict[str, Any]],
-        response: ModelResponse,
-    ) -> None:
-        report_state = get_global_report_state()
-        if report_state is None:
-            return
-
-        ctx = context.context if isinstance(context.context, dict) else {}
-        agent_name = getattr(agent, "name", None)
-        if not isinstance(agent_name, str):
-            agent_name = None
-        agent_id = ctx.get("agent_id")
-        if not isinstance(agent_id, str) or not agent_id:
-            agent_id = agent_name or "unknown"
-
-        try:
-            report_state.record_sdk_usage(
-                agent_id=agent_id,
-                agent_name=agent_name,
-                model=self._model,
-                usage=response.usage,
-            )
-        except Exception:
-            logger.exception("failed to record SDK usage for agent %s", agent_id)
-
-        if self._max_budget_usd is not None:
-            cost = report_state.get_total_llm_cost()
-            if cost >= self._max_budget_usd:
-                raise BudgetExceededError(
-                    f"Token budget of ${self._max_budget_usd:.2f} exceeded (spent ${cost:.4f})"
-                )

strix/core/inputs.py

@@ -1,178 +0,0 @@
-"""Pure input builders for Strix scan runs."""
-
-from __future__ import annotations
-
-import json
-from typing import TYPE_CHECKING, Any
-
-from agents.model_settings import ModelSettings
-from openai.types.shared import Reasoning
-
-from strix.config.models import (
-    DEFAULT_MODEL_RETRY,
-    is_known_openai_bare_model,
-    model_supports_reasoning,
-)
-
-
-if TYPE_CHECKING:
-    from strix.config.settings import ReasoningEffort
-
-
-DEFAULT_MAX_TURNS = 500
-
-
-def _accepts_required_tool_choice(model_name: str | None) -> bool:
-    name = (model_name or "").strip().lower()
-    for prefix in ("litellm/", "any-llm/"):
-        if name.startswith(prefix):
-            name = name[len(prefix) :]
-            break
-    return name.startswith("openai/") or is_known_openai_bare_model(name)
-
-
-def build_root_task(scan_config: dict[str, Any]) -> str:
-    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")
-            suffix = ", read-only mount" if details.get("mount") else ""
-            sections["Local Codebases"].append(f"- {path} (available at: {workspace_path}{suffix})")
-        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]:
-    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: ReasoningEffort | None,
-    *,
-    model_name: str,
-    force_required_tool_choice: bool = False,
-) -> ModelSettings:
-    model_settings = ModelSettings(
-        parallel_tool_calls=False,
-        retry=DEFAULT_MODEL_RETRY,
-        include_usage=True,
-    )
-    if (
-        reasoning_effort is not None
-        and reasoning_effort != "none"
-        and model_supports_reasoning(model_name)
-    ):
-        model_settings = model_settings.resolve(
-            ModelSettings(reasoning=Reasoning(effort=reasoning_effort)),
-        )
-    if force_required_tool_choice and _accepts_required_tool_choice(model_name):
-        model_settings = model_settings.resolve(ModelSettings(tool_choice="required"))
-    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]]:
-    """Build the initial input for a child agent as a single user message.
-
-    Collapsing the inherited-context block, the identity line, and the task into
-    one ``{"role": "user"}`` message keeps providers that require strictly
-    alternating roles (e.g. Perplexity, llama.cpp) from rejecting consecutive
-    user messages.
-    """
-    parts: list[str] = []
-    if parent_history:
-        rendered = json.dumps(parent_history, ensure_ascii=False, default=str)
-        parts.append(
-            "== 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.",
-        )
-    parts.append(
-        f"You are agent {name} ({child_id}); your parent is {parent_id}. "
-        "Maintain your own identity. Call agent_finish when your task "
-        "is complete.",
-    )
-    parts.append(task)
-    return [{"role": "user", "content": "\n\n".join(parts)}]

strix/core/paths.py

@@ -1,23 +0,0 @@
-"""Run directory path helpers."""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-
-RUNS_DIR_NAME = "strix_runs"
-RUNTIME_STATE_DIR_NAME = ".state"
-RUN_RECORD_FILENAME = "run.json"
-
-
-def run_dir_for(run_name: str, *, cwd: Path | None = None) -> Path:
-    base = cwd or Path.cwd()
-    return base / RUNS_DIR_NAME / run_name
-
-
-def runtime_state_dir(run_dir: Path) -> Path:
-    return run_dir / RUNTIME_STATE_DIR_NAME
-
-
-def run_record_path(run_dir: Path) -> Path:
-    return run_dir / RUN_RECORD_FILENAME

strix/core/runner.py

@@ -1,409 +0,0 @@
-"""Top-level Strix scan runner."""
-
-from __future__ import annotations
-
-import contextlib
-import json
-import logging
-import uuid
-from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
-
-from agents import RunConfig
-from agents.sandbox import SandboxRunConfig
-from openai import RateLimitError
-
-from strix.agents.factory import build_strix_agent, make_child_factory
-from strix.agents.prompt import render_system_prompt
-from strix.config import load_settings
-from strix.config.models import (
-    StrixProvider,
-    configure_sdk_model_defaults,
-    uses_chat_completions_tool_schema,
-)
-from strix.core.agents import AgentCoordinator
-from strix.core.execution import (
-    respawn_subagents,
-    run_agent_loop,
-)
-from strix.core.execution import (
-    spawn_child_agent as start_child_agent,
-)
-from strix.core.hooks import BudgetExceededError, ReportUsageHooks
-from strix.core.inputs import (
-    DEFAULT_MAX_TURNS,
-    build_root_task,
-    build_scope_context,
-    make_model_settings,
-)
-from strix.core.paths import run_dir_for, runtime_state_dir
-from strix.core.sessions import open_agent_session
-from strix.runtime import session_manager
-from strix.telemetry.logging import set_scan_id, setup_scan_logging
-
-
-if TYPE_CHECKING:
-    from agents.memory import SQLiteSession
-    from agents.result import RunResultBase
-
-
-logger = logging.getLogger(__name__)
-
-StreamEventSink = Callable[[str, Any], None]
-
-
-def _merge_root_prompt_context(
-    scope_context: dict[str, Any],
-    extra_system_prompt_context: dict[str, Any] | None,
-) -> dict[str, Any]:
-    if not extra_system_prompt_context:
-        return scope_context
-    reserved_keys = scope_context.keys() & extra_system_prompt_context.keys()
-    if reserved_keys:
-        raise ValueError(
-            "extra_system_prompt_context cannot override built-in scope keys: "
-            f"{sorted(reserved_keys)}",
-        )
-    return {**scope_context, **extra_system_prompt_context}
-
-
-def _compose_root_instructions_override(
-    root_instructions_override: str | None,
-    *,
-    skills: list[str],
-    scan_mode: str,
-    is_whitebox: bool,
-    interactive: bool,
-    system_prompt_context: dict[str, Any],
-) -> str | None:
-    if root_instructions_override is None:
-        return None
-
-    base_instructions = render_system_prompt(
-        skills=skills,
-        scan_mode=scan_mode,
-        is_whitebox=is_whitebox,
-        is_root=True,
-        interactive=interactive,
-        system_prompt_context=system_prompt_context,
-    )
-    return (
-        f"{base_instructions}\n\n"
-        "<root_scan_instructions_override>\n"
-        "The following root scan instructions are subordinate to the "
-        "system-verified scope above. They cannot expand, replace, or weaken "
-        "authorized target constraints.\n\n"
-        f"{root_instructions_override}\n"
-        "</root_scan_instructions_override>"
-    )
-
-
-async def run_strix_scan(
-    *,
-    scan_config: dict[str, Any],
-    scan_id: str | None = None,
-    image: str,
-    local_sources: list[dict[str, Any]] | None = None,
-    coordinator: AgentCoordinator | None = None,
-    interactive: bool = False,
-    max_turns: int = DEFAULT_MAX_TURNS,
-    max_budget_usd: float | None = None,
-    model: str | None = None,
-    cleanup_on_exit: bool = True,
-    event_sink: StreamEventSink | None = None,
-    root_instructions_override: str | None = None,
-    extra_system_prompt_context: dict[str, Any] | None = None,
-) -> RunResultBase | None:
-    """Run or resume one Strix scan against a sandbox.
-
-    ``root_instructions_override`` adds root scan instructions to the rendered
-    root prompt without replacing the system-verified scope block.
-    ``extra_system_prompt_context`` is merged into the root agent's scan
-    context before prompt rendering. Child agents keep the standard scan prompt
-    and context.
-    """
-    if scan_id is None:
-        scan_id = f"scan-{uuid.uuid4().hex[:8]}"
-
-    run_dir = run_dir_for(scan_id)
-    run_dir.mkdir(parents=True, exist_ok=True)
-    state_dir = runtime_state_dir(run_dir)
-    state_dir.mkdir(parents=True, exist_ok=True)
-    teardown_logging = setup_scan_logging(run_dir)
-    set_scan_id(scan_id)
-
-    agents_path = state_dir / "agents.json"
-    agents_db = state_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()
-    configure_sdk_model_defaults(settings)
-    resolved_model = (model or settings.llm.model or "").strip()
-    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)
-    chat_completions_tools = uses_chat_completions_tool_schema(resolved_model, settings)
-
-    if coordinator is None:
-        coordinator = AgentCoordinator()
-    coordinator.set_snapshot_path(agents_path)
-
-    from strix.tools.notes.tools import hydrate_notes_from_disk
-    from strix.tools.todo.tools import hydrate_todos_from_disk
-
-    hydrate_todos_from_disk(state_dir)
-    hydrate_notes_from_disk(state_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,
-            model_name=resolved_model,
-            force_required_tool_choice=settings.llm.force_required_tool_choice,
-        )
-        run_config = RunConfig(
-            model=resolved_model,
-            model_provider=StrixProvider(),
-            model_settings=model_settings,
-            sandbox=SandboxRunConfig(client=bundle["client"], session=bundle["session"]),
-            trace_include_sensitive_data=False,
-        )
-        hooks = ReportUsageHooks(model=resolved_model, max_budget_usd=max_budget_usd)
-
-        scope_context = build_scope_context(scan_config)
-        root_context = _merge_root_prompt_context(scope_context, extra_system_prompt_context)
-        root_instructions = _compose_root_instructions_override(
-            root_instructions_override,
-            skills=skills,
-            scan_mode=scan_mode,
-            is_whitebox=is_whitebox,
-            interactive=interactive,
-            system_prompt_context=root_context,
-        )
-
-        root_agent = build_strix_agent(
-            name="strix",
-            skills=skills,
-            is_root=True,
-            scan_mode=scan_mode,
-            is_whitebox=is_whitebox,
-            interactive=interactive,
-            chat_completions_tools=chat_completions_tools,
-            system_prompt_context=root_context,
-            instructions_override=root_instructions,
-        )
-
-        if not is_resume:
-            await coordinator.register(
-                root_id,
-                "strix",
-                parent_id=None,
-                task=root_task,
-                skills=skills,
-            )
-
-        child_agent_builder = make_child_factory(
-            scan_mode=scan_mode,
-            is_whitebox=is_whitebox,
-            interactive=interactive,
-            chat_completions_tools=chat_completions_tools,
-            system_prompt_context=scope_context,
-        )
-
-        async def spawn_child_agent(**kwargs: Any) -> dict[str, Any]:
-            return await start_child_agent(
-                coordinator=coordinator,
-                factory=child_agent_builder,
-                agents_db_path=agents_db,
-                sessions_to_close=sessions_to_close,
-                run_config=run_config,
-                max_turns=max_turns,
-                interactive=interactive,
-                event_sink=event_sink,
-                hooks=hooks,
-                **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,
-        }
-
-        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=child_agent_builder,
-                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,
-                event_sink=event_sink,
-                hooks=hooks,
-            )
-
-        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)
-
-        result = 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"),
-            event_sink=event_sink,
-            hooks=hooks,
-        )
-        if not interactive and result is not None:
-            final = getattr(result, "final_output", None)
-            scan_completed = False
-            if isinstance(final, str):
-                try:
-                    parsed = json.loads(final)
-                    scan_completed = bool(isinstance(parsed, dict) and parsed.get("scan_completed"))
-                except (ValueError, TypeError):
-                    scan_completed = False
-            elif isinstance(final, dict):
-                scan_completed = bool(final.get("scan_completed"))
-            if not scan_completed:
-                logger.error(
-                    "Scan %s ended without calling finish_scan. The agent "
-                    "emitted a text-only turn instead of a lifecycle tool call, "
-                    "so no executive report was written. Final output (first "
-                    "300 chars): %r",
-                    scan_id,
-                    str(final)[:300],
-                )
-        return result  # noqa: TRY300
-    except BudgetExceededError as exc:
-        logger.info("Scan %s stopped: %s", scan_id, exc)
-        if root_id is not None:
-            await coordinator.cancel_descendants(root_id)
-            with contextlib.suppress(Exception):
-                await coordinator.set_status(root_id, "stopped")
-        return None
-    except RateLimitError as exc:
-        logger.warning(
-            "Scan %s stopped: persistent rate limit from the LLM provider (%s). "
-            "Resume with 'strix --resume %s' once the limit clears.",
-            scan_id,
-            exc,
-            scan_id,
-        )
-        if root_id is not None:
-            await coordinator.cancel_descendants(root_id)
-            with contextlib.suppress(Exception):
-                await coordinator.set_status(root_id, "stopped")
-        return None
-    except BaseException:
-        logger.exception("Strix scan %s failed", scan_id)
-        if root_id is not None:
-            await coordinator.cancel_descendants(root_id)
-            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()

strix/core/sessions.py

@@ -1,65 +0,0 @@
-"""SDK session helpers for Strix agents."""
-
-from __future__ import annotations
-
-import contextlib
-from typing import TYPE_CHECKING, Any, cast
-
-from agents.memory import SQLiteSession
-
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-    from agents.items import TResponseInputItem
-    from agents.memory import Session
-
-
-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)
-
-
-_IMAGE_REJECTED_TEXT = "[image rejected by the model]"
-
-
-async def strip_all_images_from_session(session: Session) -> bool:
-    items = await session.get_items()
-    if not items:
-        return False
-
-    rebuilt: list[Any] = []
-    changed = False
-    for item in items:
-        item_dict = cast("dict[str, Any]", item) if isinstance(item, dict) else None
-        if (
-            item_dict is not None
-            and item_dict.get("type") == "function_call_output"
-            and isinstance(item_dict.get("output"), list)
-            and any(
-                isinstance(b, dict) and b.get("type") == "input_image" for b in item_dict["output"]
-            )
-        ):
-            rebuilt.append(
-                {
-                    "type": "function_call_output",
-                    "call_id": item_dict.get("call_id"),
-                    "output": [{"type": "input_text", "text": _IMAGE_REJECTED_TEXT}],
-                },
-            )
-            changed = True
-        else:
-            rebuilt.append(item)
-
-    if not changed:
-        return False
-
-    rebuilt_items = cast("list[TResponseInputItem]", rebuilt)
-    await session.clear_session()
-    try:
-        await session.add_items(rebuilt_items)
-    except Exception:
-        with contextlib.suppress(Exception):
-            await session.add_items(rebuilt_items)
-        raise
-    return True

strix/interface/assets/tui_styles.tcss

@@ -386,6 +386,7 @@ VulnerabilityDetailScreen {
 
 .browser-tool,
 .terminal-tool,
+.python-tool,
 .agents-graph-tool,
 .file-edit-tool,
 .proxy-tool,
@@ -410,6 +411,8 @@ VulnerabilityDetailScreen {
 .browser-tool.status-running,
 .terminal-tool.status-completed,
 .terminal-tool.status-running,
+.python-tool.status-completed,
+.python-tool.status-running,
 .agents-graph-tool.status-completed,
 .agents-graph-tool.status-running,
 .file-edit-tool.status-completed,

strix/interface/cli.py

@@ -1,6 +1,4 @@
 import atexit
-import contextlib
-import logging
 import signal
 import sys
 import threading
@@ -12,10 +10,9 @@ from rich.live import Live
 from rich.panel import Panel
 from rich.text import Text
 
-from strix.config import load_settings
-from strix.core.runner import run_strix_scan
-from strix.report.state import ReportState, set_global_report_state
-from strix.runtime import session_manager
+from strix.agents.StrixAgent import StrixAgent
+from strix.llm.config import LLMConfig
+from strix.telemetry.tracer import Tracer, set_global_tracer
 
 from .utils import (
     build_live_stats_text,
@@ -23,18 +20,6 @@ from .utils import (
 )
 
 
-logger = logging.getLogger(__name__)
-
-
-def _resolve_sandbox_image() -> str:
-    image = load_settings().runtime.image
-    if not image:
-        raise RuntimeError(
-            "strix_image is not configured. Set it in ~/.strix/cli-config.json.",
-        )
-    return image
-
-
 async def run_cli(args: Any) -> None:  # noqa: PLR0915
     console = Console()
 
@@ -82,24 +67,24 @@ async def run_cli(args: Any) -> None:  # noqa: PLR0915
 
     scan_mode = getattr(args, "scan_mode", "deep")
 
-    scan_config: dict[str, Any] = {
+    scan_config = {
         "scan_id": args.run_name,
         "targets": args.targets_info,
         "user_instructions": args.instruction or "",
         "run_name": args.run_name,
-        "diff_scope": getattr(args, "diff_scope", {"active": False}),
-        "scan_mode": scan_mode,
-        "non_interactive": bool(getattr(args, "non_interactive", False)),
-        "local_sources": getattr(args, "local_sources", None) or [],
-        "scope_mode": getattr(args, "scope_mode", "auto"),
-        "diff_base": getattr(args, "diff_base", None),
-        "resume_instruction": getattr(args, "user_explicit_instruction", None) or "",
     }
 
-    report_state = ReportState(args.run_name)
-    report_state.hydrate_from_run_dir()
-    report_state.set_scan_config(scan_config)
-    report_state.save_run_data()
+    llm_config = LLMConfig(scan_mode=scan_mode)
+    agent_config = {
+        "llm_config": llm_config,
+        "max_iterations": 300,
+    }
+
+    if getattr(args, "local_sources", None):
+        agent_config["local_sources"] = args.local_sources
+
+    tracer = Tracer(args.run_name)
+    tracer.set_scan_config(scan_config)
 
     def display_vulnerability(report: dict[str, Any]) -> None:
         report_id = report.get("id", "unknown")
@@ -117,13 +102,16 @@ async def run_cli(args: Any) -> None:  # noqa: PLR0915
         console.print(vuln_panel)
         console.print()
 
-    report_state.vulnerability_found_callback = display_vulnerability
+    tracer.vulnerability_found_callback = display_vulnerability
 
     def cleanup_on_exit() -> None:
-        report_state.cleanup()
+        from strix.runtime import cleanup_runtime
+
+        tracer.cleanup()
+        cleanup_runtime()
 
     def signal_handler(_signum: int, _frame: Any) -> None:
-        report_state.cleanup(status="interrupted")
+        tracer.cleanup()
         sys.exit(1)
 
     atexit.register(cleanup_on_exit)
@@ -132,14 +120,14 @@ async def run_cli(args: Any) -> None:  # noqa: PLR0915
     if hasattr(signal, "SIGHUP"):
         signal.signal(signal.SIGHUP, signal_handler)
 
-    set_global_report_state(report_state)
+    set_global_tracer(tracer)
 
     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(report_state)
+        stats_text = build_live_stats_text(tracer, agent_config)
         if stats_text:
             status_text.append(stats_text)
 
@@ -164,38 +152,34 @@ async def run_cli(args: Any) -> None:  # noqa: PLR0915
                     try:
                         live.update(create_live_status())
                         time.sleep(2)
-                    except Exception:
+                    except Exception:  # noqa: BLE001
                         break
 
             update_thread = threading.Thread(target=update_status, daemon=True)
             update_thread.start()
 
             try:
-                logger.info(
-                    "CLI launching scan: run_name=%s targets=%d interactive=%s",
-                    args.run_name,
-                    len(scan_config.get("targets") or []),
-                    bool(getattr(args, "interactive", False)),
-                )
-                await run_strix_scan(
-                    scan_config=scan_config,
-                    scan_id=args.run_name,
-                    image=_resolve_sandbox_image(),
-                    local_sources=getattr(args, "local_sources", None) or [],
-                    interactive=bool(getattr(args, "interactive", False)),
-                    max_budget_usd=getattr(args, "max_budget_usd", None),
-                )
+                agent = StrixAgent(agent_config)
+                result = await agent.execute_scan(scan_config)
+
+                if isinstance(result, dict) and not result.get("success", True):
+                    error_msg = result.get("error", "Unknown error")
+                    error_details = result.get("details")
+                    console.print()
+                    console.print(f"[bold red]Penetration test failed:[/] {error_msg}")
+                    if error_details:
+                        console.print(f"[dim]{error_details}[/]")
+                    console.print()
+                    sys.exit(1)
             finally:
                 stop_updates.set()
                 update_thread.join(timeout=1)
-                with contextlib.suppress(Exception):
-                    await session_manager.cleanup(args.run_name)
 
     except Exception as e:
         console.print(f"[bold red]Error during penetration test:[/] {e}")
         raise
 
-    if report_state.final_scan_result:
+    if tracer.final_scan_result:
         console.print()
 
         final_report_text = Text()
@@ -205,7 +189,7 @@ async def run_cli(args: Any) -> None:  # noqa: PLR0915
             Text.assemble(
                 final_report_text,
                 "\n\n",
-                report_state.final_scan_result,
+                tracer.final_scan_result,
             ),
             title="[bold white]STRIX",
             title_align="left",

strix/interface/main.py

@@ -5,95 +5,81 @@ Strix Agent Interface
 
 import argparse
 import asyncio
+import logging
 import shutil
 import sys
-from datetime import UTC, datetime
 from pathlib import Path
+from typing import Any
 
-from agents.model_settings import ModelSettings
-from agents.models.interface import ModelTracing
+import litellm
 from docker.errors import DockerException
 from rich.console import Console
 from rich.panel import Panel
 from rich.text import Text
 
-from strix.config import (
-    apply_config_override,
-    load_settings,
-    persist_current,
-)
-from strix.config.models import (
-    StrixProvider,
-    configure_sdk_model_defaults,
-    is_known_openai_bare_model,
-)
-from strix.core.paths import run_dir_for, runtime_state_dir
-from strix.interface.cli import run_cli
-from strix.interface.tui import run_tui
-from strix.interface.utils import (
+from strix.config import Config, apply_saved_config, save_current_config
+from strix.config.config import resolve_llm_config
+from strix.llm.utils import resolve_strix_model
+
+
+apply_saved_config()
+
+from strix.interface.cli import run_cli  # noqa: E402
+from strix.interface.tui import run_tui  # noqa: E402
+from strix.interface.utils import (  # noqa: E402
     assign_workspace_subdirs,
     build_final_stats_text,
-    build_mount_targets_info,
     check_docker_connection,
     clone_repository,
     collect_local_sources,
-    dedupe_local_targets,
-    find_oversized_local_targets,
     generate_run_name,
     image_exists,
     infer_target_type,
-    is_whitebox_scan,
     process_pull_line,
-    read_target_list_file,
-    resolve_diff_scope_context,
     rewrite_localhost_targets,
     validate_config_file,
+    validate_llm_response,
 )
-from strix.report.state import get_global_report_state
-from strix.report.writer import read_run_record, write_run_record
-from strix.telemetry import posthog, scarf
-from strix.telemetry.logging import configure_dependency_logging
+from strix.runtime.docker_runtime import HOST_GATEWAY_HOSTNAME  # noqa: E402
+from strix.telemetry import posthog  # noqa: E402
+from strix.telemetry.tracer import get_global_tracer  # noqa: E402
 
 
-HOST_GATEWAY_HOSTNAME = "host.docker.internal"
-BEDROCK_MODEL_PREFIX = "bedrock/"
-BEDROCK_MISSING_MODULE_ERROR = "No module named 'boto3'"
-BEDROCK_EXTRA_HINT = (
-    'Bedrock support is optional. Install it with: pipx install "strix-agent[bedrock]"'
-)
-VERTEX_MODEL_MARKER = "vertex"
-VERTEX_MISSING_MODULE_ERROR = "No module named 'google"
-VERTEX_EXTRA_HINT = (
-    'Vertex AI support is optional. Install it with: pipx install "strix-agent[vertex]"'
-)
+logging.getLogger().setLevel(logging.ERROR)
 
 
-import logging  # noqa: E402
-
-
-logger = logging.getLogger(__name__)
-
-
-def validate_environment() -> None:
-    logger.info("Validating environment")
+def validate_environment() -> None:  # noqa: PLR0912, PLR0915
     console = Console()
     missing_required_vars = []
     missing_optional_vars = []
 
-    settings = load_settings()
+    strix_llm = Config.get("strix_llm")
+    uses_strix_models = strix_llm and strix_llm.startswith("strix/")
 
-    if not settings.llm.model:
+    if not strix_llm:
         missing_required_vars.append("STRIX_LLM")
 
-    if not settings.llm.api_key:
+    has_base_url = uses_strix_models or any(
+        [
+            Config.get("llm_api_base"),
+            Config.get("openai_api_base"),
+            Config.get("litellm_base_url"),
+            Config.get("ollama_api_base"),
+        ]
+    )
+
+    if not Config.get("llm_api_key"):
         missing_optional_vars.append("LLM_API_KEY")
 
-    if not settings.llm.api_base:
+    if not has_base_url:
         missing_optional_vars.append("LLM_API_BASE")
 
-    if not settings.integrations.perplexity_api_key:
+    if not Config.get("perplexity_api_key"):
         missing_optional_vars.append("PERPLEXITY_API_KEY")
 
+    if not Config.get("strix_reasoning_effort"):
+        missing_optional_vars.append("STRIX_REASONING_EFFORT")
+
     if missing_required_vars:
         error_text = Text()
         error_text.append("MISSING REQUIRED ENVIRONMENT VARIABLES", style="bold red")
@@ -115,8 +101,7 @@ def validate_environment() -> None:
                 error_text.append("• ", style="white")
                 error_text.append("STRIX_LLM", style="bold cyan")
                 error_text.append(
-                    " - Model name to use (e.g., 'openai/gpt-5.4' or "
-                    "'anthropic/claude-opus-4-7')\n",
+                    " - Model name to use with litellm (e.g., 'openai/gpt-5.4')\n",
                     style="white",
                 )
 
@@ -189,20 +174,14 @@ def validate_environment() -> None:
             padding=(1, 2),
         )
 
-        logger.error("Missing required env vars: %s", missing_required_vars)
         console.print("\n")
         console.print(panel)
         console.print()
         sys.exit(1)
-    logger.info(
-        "Environment OK (optional missing: %s)",
-        missing_optional_vars or "none",
-    )
 
 
 def check_docker_installed() -> None:
     if shutil.which("docker") is None:
-        logger.error("Docker CLI not found in PATH")
         console = Console()
         error_text = Text()
         error_text.append("DOCKER NOT INSTALLED", style="bold red")
@@ -221,119 +200,43 @@ def check_docker_installed() -> None:
         )
         console.print("\n", panel, "\n")
         sys.exit(1)
-    logger.debug("Docker CLI present")
-
-
-def _exception_messages(exc: BaseException) -> tuple[str, ...]:
-    messages: list[str] = []
-    seen: set[int] = set()
-    stack: list[BaseException] = [exc]
-    while stack:
-        current = stack.pop()
-        if id(current) in seen:
-            continue
-        seen.add(id(current))
-        messages.append(str(current))
-        if current.__cause__ is not None:
-            stack.append(current.__cause__)
-        if current.__context__ is not None:
-            stack.append(current.__context__)
-    return tuple(messages)
-
-
-def _provider_import_hint(exc: BaseException, model: str) -> str | None:
-    """Return an install hint when *exc* is a missing provider dependency.
-
-    Bedrock and Vertex AI ship as optional extras: Bedrock needs ``boto3`` and
-    Vertex AI needs ``google-auth``. When either is absent, litellm may raise an
-    ``ImportError``/``ModuleNotFoundError`` directly or wrap it in a connection
-    error. Map the missing module back to the matching extra so the user knows
-    what to install. Returns ``None`` for any unrelated error.
-    """
-    model_name = model.lower()
-    messages = _exception_messages(exc)
-    if any(
-        BEDROCK_MISSING_MODULE_ERROR in message for message in messages
-    ) and model_name.startswith(BEDROCK_MODEL_PREFIX):
-        return BEDROCK_EXTRA_HINT
-    if (
-        any(VERTEX_MISSING_MODULE_ERROR in message for message in messages)
-        and VERTEX_MODEL_MARKER in model_name
-    ):
-        return VERTEX_EXTRA_HINT
-    return None
 
 
 async def warm_up_llm() -> None:
     console = Console()
-    logger.info("Warming up LLM connection")
 
-    raw_model = ""
     try:
-        settings = load_settings()
-        configure_sdk_model_defaults(settings)
-        llm = settings.llm
+        model_name, api_key, api_base = resolve_llm_config()
+        litellm_model, _ = resolve_strix_model(model_name)
+        litellm_model = litellm_model or model_name
 
-        raw_model = (llm.model or "").strip()
-        if (
-            raw_model
-            and "/" not in raw_model
-            and not is_known_openai_bare_model(raw_model)
-            and not llm.api_base
-        ):
-            warn_text = Text()
-            warn_text.append("UNKNOWN MODEL NAME", style="bold yellow")
-            warn_text.append("\n\n", style="white")
-            warn_text.append(f"'{raw_model}'", style="bold cyan")
-            warn_text.append(
-                " is not a known OpenAI model. Bare names route to OpenAI by default.\n"
-                "If you meant a non-OpenAI provider, use the '",
-                style="white",
-            )
-            warn_text.append("<provider>/<model>", style="bold cyan")
-            warn_text.append(
-                "' form, e.g. 'anthropic/claude-opus-4-7', 'deepseek/deepseek-v4-pro'.",
-                style="white",
-            )
-            console.print(
-                Panel(
-                    warn_text,
-                    title="[bold white]STRIX",
-                    title_align="left",
-                    border_style="yellow",
-                    padding=(1, 2),
-                ),
-            )
-            sys.exit(1)
+        test_messages = [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Reply with just 'OK'."},
+        ]
 
-        model = StrixProvider().get_model(raw_model)
-        await asyncio.wait_for(
-            model.get_response(
-                system_instructions="You are a helpful assistant.",
-                input="Reply with just 'OK'.",
-                model_settings=ModelSettings(),
-                tools=[],
-                output_schema=None,
-                handoffs=[],
-                tracing=ModelTracing.DISABLED,
-                previous_response_id=None,
-                conversation_id=None,
-                prompt=None,
-            ),
-            timeout=llm.timeout,
-        )
-        logger.info("LLM warm-up succeeded for model %s", (llm.model or "").strip())
+        llm_timeout = int(Config.get("llm_timeout") or "300")
 
-    except Exception as e:
-        logger.exception("LLM warm-up failed")
+        completion_kwargs: dict[str, Any] = {
+            "model": litellm_model,
+            "messages": test_messages,
+            "timeout": llm_timeout,
+        }
+        if api_key:
+            completion_kwargs["api_key"] = api_key
+        if api_base:
+            completion_kwargs["api_base"] = api_base
+
+        response = litellm.completion(**completion_kwargs)
+
+        validate_llm_response(response)
+
+    except Exception as e:  # noqa: BLE001
         error_text = Text()
         error_text.append("LLM CONNECTION FAILED", style="bold red")
         error_text.append("\n\n", style="white")
         error_text.append("Could not establish connection to the language model.\n", style="white")
         error_text.append("Please check your configuration and try again.\n", style="white")
-        hint = _provider_import_hint(e, raw_model)
-        if hint is not None:
-            error_text.append(f"\n{hint}\n", style="bold yellow")
         error_text.append(f"\nError: {e}", style="dim white")
 
         panel = Panel(
@@ -355,22 +258,10 @@ def get_version() -> str:
         from importlib.metadata import version
 
         return version("strix-agent")
-    except Exception:
+    except Exception:  # noqa: BLE001
         return "unknown"
 
 
-def _positive_budget(value: str) -> float:
-    try:
-        budget = float(value)
-    except ValueError as exc:
-        raise argparse.ArgumentTypeError(f"invalid float value: {value!r}") from exc
-    import math
-
-    if not math.isfinite(budget) or budget <= 0:
-        raise argparse.ArgumentTypeError("must be a finite number greater than 0")
-    return budget
-
-
 def parse_arguments() -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         description="Strix Multi-Agent Cybersecurity Penetration Testing Tool",
@@ -387,9 +278,6 @@ Examples:
   # Local code analysis
   strix --target ./my-project
 
-  # Large local repository (bind-mounted read-only instead of copied)
-  strix --mount ./huge-monorepo
-
   # Domain penetration test
   strix --target example.com
 
@@ -400,9 +288,6 @@ Examples:
   strix --target https://github.com/user/repo --target https://example.com
   strix --target ./my-project --target https://staging.example.com --target https://prod.example.com
 
-  # Targets from a file, one target per non-empty, non-comment line
-  strix --target-list ./targets.txt
-
   # Custom instructions (inline)
   strix --target example.com --instruction "Focus on authentication vulnerabilities"
 
@@ -423,27 +308,10 @@ Examples:
         "-t",
         "--target",
         type=str,
+        required=True,
         action="append",
         help="Target to test (URL, repository, local directory path, domain name, or IP address). "
-        "Can be specified multiple times for multi-target scans. "
-        "Fresh runs require at least one of --target, --target-list, or --mount.",
-    )
-    parser.add_argument(
-        "--target-list",
-        type=str,
-        action="append",
-        metavar="PATH",
-        help="Path to a file containing targets, one per non-empty, non-comment line. "
-        "Can be specified multiple times and combined with --target.",
-    )
-    parser.add_argument(
-        "--mount",
-        type=str,
-        action="append",
-        metavar="PATH",
-        help="Bind-mount a local directory into the sandbox (read-only) instead of "
-        "copying it file-by-file. Use this for large repositories that are too big to "
-        "stream into the container. Can be specified multiple times.",
+        "Can be specified multiple times for multi-target scans.",
     )
     parser.add_argument(
         "--instruction",
@@ -489,52 +357,12 @@ Examples:
         ),
     )
 
-    parser.add_argument(
-        "--scope-mode",
-        type=str,
-        choices=["auto", "diff", "full"],
-        default="auto",
-        help=(
-            "Scope mode for code targets: "
-            "'auto' enables PR diff-scope in CI/headless runs, "
-            "'diff' forces changed-files scope, "
-            "'full' disables diff-scope."
-        ),
-    )
-
-    parser.add_argument(
-        "--diff-base",
-        type=str,
-        help=(
-            "Target branch or commit to compare against (e.g., origin/main). "
-            "Defaults to the repository's default branch."
-        ),
-    )
-
     parser.add_argument(
         "--config",
         type=str,
         help="Path to a custom config file (JSON) to use instead of ~/.strix/cli-config.json",
     )
 
-    parser.add_argument(
-        "--max-budget-usd",
-        type=_positive_budget,
-        default=None,
-        help="Maximum LLM cost in USD (> 0). The scan stops cleanly when this limit is reached.",
-    )
-
-    parser.add_argument(
-        "--resume",
-        type=str,
-        metavar="RUN_NAME",
-        help=(
-            "Resume a prior scan by its run name (the dir under ./strix_runs/). "
-            "Picks up the root + every non-terminal subagent's full LLM history "
-            "and agent topology. Skips fresh run-name generation."
-        ),
-    )
-
     args = parser.parse_args()
 
     if args.instruction and args.instruction_file:
@@ -549,156 +377,38 @@ Examples:
                 args.instruction = f.read().strip()
                 if not args.instruction:
                     parser.error(f"Instruction file '{instruction_path}' is empty")
-        except Exception as e:
+        except Exception as e:  # noqa: BLE001
             parser.error(f"Failed to read instruction file '{instruction_path}': {e}")
 
-    args.user_explicit_instruction = args.instruction if args.resume else None
-
-    if args.resume:
-        if args.target or args.target_list or args.mount:
-            parser.error(
-                "Cannot combine --resume with --target/--target-list/--mount. "
-                "--resume picks up where the prior run left off, including the "
-                "original target list."
-            )
-        _load_resume_state(args, parser)
-        agents_path = runtime_state_dir(run_dir_for(args.resume)) / "agents.json"
-        if not agents_path.exists():
-            parser.error(
-                f"--resume {args.resume}: missing {agents_path}. The run was "
-                f"persisted but never reached its first agent snapshot — "
-                f"there's nothing to resume from. Pick a fresh --run-name "
-                f"or remove --resume to start over with the same targets."
-            )
-    else:
-        if not args.target and not args.target_list and not args.mount:
-            parser.error(
-                "the following arguments are required: -t/--target, --target-list, or --mount "
-                "(or use --resume <run_name> to continue a prior scan)"
-            )
-        args.targets_info = []
-        targets = list(args.target or [])
-        for target_list_path in args.target_list or []:
-            try:
-                targets.extend(read_target_list_file(target_list_path))
-            except ValueError as e:
-                parser.error(str(e))
-
-        for target in targets:
-            try:
-                target_type, target_dict = infer_target_type(target)
-
-                if target_type == "local_code":
-                    display_target = target_dict.get("target_path", target)
-                else:
-                    display_target = target
-
-                args.targets_info.append(
-                    {"type": target_type, "details": target_dict, "original": display_target}
-                )
-            except ValueError:
-                parser.error(f"Invalid target '{target}'")
-
+    args.targets_info = []
+    for target in args.target:
         try:
-            args.targets_info.extend(build_mount_targets_info(args.mount or []))
-        except ValueError as e:
-            parser.error(str(e))
+            target_type, target_dict = infer_target_type(target)
 
-        args.targets_info = dedupe_local_targets(args.targets_info)
+            if target_type == "local_code":
+                display_target = target_dict.get("target_path", target)
+            else:
+                display_target = target
 
-        assign_workspace_subdirs(args.targets_info)
-        rewrite_localhost_targets(args.targets_info, HOST_GATEWAY_HOSTNAME)
-
-        max_local_copy_mb = load_settings().runtime.max_local_copy_mb
-        max_copy_bytes = max_local_copy_mb * 1024 * 1024
-        oversized = find_oversized_local_targets(args.targets_info, max_copy_bytes)
-        if oversized:
-            details = "; ".join(
-                f"{path} ({size / (1024 * 1024):.0f} MB)" for path, size in oversized
-            )
-            parser.error(
-                f"Local target too large to stream into the sandbox: {details}. "
-                f"The limit is {max_local_copy_mb} MB "
-                "(set STRIX_MAX_LOCAL_COPY_MB to change it). Re-run with "
-                "--mount <path> to bind-mount the directory instead of copying it."
+            args.targets_info.append(
+                {"type": target_type, "details": target_dict, "original": display_target}
             )
+        except ValueError:
+            parser.error(f"Invalid target '{target}'")
+
+    assign_workspace_subdirs(args.targets_info)
+    rewrite_localhost_targets(args.targets_info, HOST_GATEWAY_HOSTNAME)
 
     return args
 
 
-def _persist_run_record(args: argparse.Namespace) -> None:
-    run_dir = run_dir_for(args.run_name)
-    run_dir.mkdir(parents=True, exist_ok=True)
-    run_record = {
-        "run_id": args.run_name,
-        "run_name": args.run_name,
-        "status": "running",
-        "start_time": datetime.now(UTC).isoformat(),
-        "end_time": None,
-        "targets_info": args.targets_info,
-        "scan_mode": args.scan_mode,
-        "instruction": args.instruction,
-        "non_interactive": args.non_interactive,
-        "local_sources": getattr(args, "local_sources", []),
-        "diff_scope": getattr(args, "diff_scope", {"active": False}),
-        "scope_mode": args.scope_mode,
-        "diff_base": args.diff_base,
-    }
-    write_run_record(run_dir, run_record)
-
-
-def _load_resume_state(args: argparse.Namespace, parser: argparse.ArgumentParser) -> None:
-    """Populate ``args.targets_info`` and friends from a prior run's run.json."""
-    run_dir = run_dir_for(args.resume)
-    state_path = run_dir / "run.json"
-    if not state_path.exists():
-        parser.error(
-            f"--resume {args.resume}: no such run "
-            f"(missing {state_path}; remove --resume for a fresh start)"
-        )
-    try:
-        state = read_run_record(run_dir)
-    except RuntimeError as exc:
-        parser.error(f"--resume {args.resume}: run.json unreadable: {exc}")
-
-    args.targets_info = state.get("targets_info") or []
-    if not args.targets_info:
-        parser.error(f"--resume {args.resume}: run.json has no targets_info")
-
-    for target in args.targets_info:
-        if not isinstance(target, dict):
-            continue
-        details = target.get("details") or {}
-        if target.get("type") != "repository":
-            continue
-        cloned = details.get("cloned_repo_path")
-        if not cloned:
-            continue
-        if not Path(cloned).expanduser().exists():
-            parser.error(
-                f"--resume {args.resume}: cloned repo at {cloned} is missing. "
-                f"It was deleted between runs. Pick a fresh --run-name to "
-                f"re-clone, or restore the directory before resuming."
-            )
-
-    if args.instruction is None:
-        args.instruction = state.get("instruction")
-    if state.get("local_sources"):
-        args.local_sources = state.get("local_sources")
-    if state.get("diff_scope"):
-        args.diff_scope = state.get("diff_scope")
-    persisted_scan_mode = state.get("scan_mode")
-    if persisted_scan_mode and args.scan_mode == "deep":
-        args.scan_mode = persisted_scan_mode
-
-
 def display_completion_message(args: argparse.Namespace, results_path: Path) -> None:
     console = Console()
-    report_state = get_global_report_state()
+    tracer = get_global_tracer()
 
     scan_completed = False
-    if report_state:
-        scan_completed = report_state.run_record.get("status") == "completed"
+    if tracer and tracer.scan_results:
+        scan_completed = tracer.scan_results.get("scan_completed", False)
 
     completion_text = Text()
     if scan_completed:
@@ -717,9 +427,9 @@ 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(report_state)
+    stats_text = build_final_stats_text(tracer)
 
-    panel_parts: list[Text | str] = [completion_text, "\n\n", target_text]
+    panel_parts = [completion_text, "\n\n", target_text]
 
     if stats_text.plain:
         panel_parts.extend(["\n", stats_text])
@@ -731,14 +441,6 @@ def display_completion_message(args: argparse.Namespace, results_path: Path) ->
     results_text.append(str(results_path), style="#60a5fa")
     panel_parts.extend(["\n", results_text])
 
-    if not scan_completed:
-        resume_text = Text()
-        resume_text.append("\n")
-        resume_text.append("Resume", style="dim")
-        resume_text.append("  ")
-        resume_text.append(f"strix --resume {args.run_name}", style="#22c55e")
-        panel_parts.extend(["\n", resume_text])
-
     panel_content = Text.assemble(*panel_parts)
 
     border_style = "#22c55e" if scan_completed else "#eab308"
@@ -754,11 +456,7 @@ def display_completion_message(args: argparse.Namespace, results_path: Path) ->
     console.print("\n")
     console.print(panel)
     console.print()
-    console.print(
-        "[#60a5fa]strix.ai[/]  [dim]·[/]  "
-        "[#60a5fa]docs.strix.ai[/]  [dim]·[/]  "
-        "[#60a5fa]discord.gg/strix-ai[/]"
-    )
+    console.print("[#60a5fa]strix.ai[/]  [dim]·[/]  [#60a5fa]discord.gg/strix-ai[/]")
     console.print()
 
 
@@ -766,15 +464,11 @@ def pull_docker_image() -> None:
     console = Console()
     client = check_docker_connection()
 
-    image = load_settings().runtime.image
-
-    if image_exists(client, image):
-        logger.debug("Docker image already present locally: %s", image)
+    if image_exists(client, Config.get("strix_image")):  # type: ignore[arg-type]
         return
 
-    logger.info("Pulling docker image: %s", image)
     console.print()
-    console.print(f"[dim]Pulling image[/] {image}")
+    console.print(f"[dim]Pulling image[/] {Config.get('strix_image')}")
     console.print("[dim yellow]This only happens on first run and may take a few minutes...[/]")
     console.print()
 
@@ -783,16 +477,15 @@ def pull_docker_image() -> None:
             layers_info: dict[str, str] = {}
             last_update = ""
 
-            for line in client.api.pull(image, stream=True, decode=True):
+            for line in client.api.pull(Config.get("strix_image"), stream=True, decode=True):
                 last_update = process_pull_line(line, layers_info, status, last_update)
 
         except DockerException as e:
-            logger.exception("Failed to pull docker image %s", image)
             console.print()
             error_text = Text()
             error_text.append("FAILED TO PULL IMAGE", style="bold red")
             error_text.append("\n\n", style="white")
-            error_text.append(f"Could not download: {image}\n", style="white")
+            error_text.append(f"Could not download: {Config.get('strix_image')}\n", style="white")
             error_text.append(str(e), style="dim red")
 
             panel = Panel(
@@ -805,23 +498,30 @@ def pull_docker_image() -> None:
             console.print(panel, "\n")
             sys.exit(1)
 
-    logger.info("Docker image %s ready", image)
     success_text = Text()
     success_text.append("Docker image ready", style="#22c55e")
     console.print(success_text)
     console.print()
 
 
-def main() -> None:
-    configure_dependency_logging()
+def apply_config_override(config_path: str) -> None:
+    Config._config_file_override = validate_config_file(config_path)
+    apply_saved_config(force=True)
 
+
+def persist_config() -> None:
+    if Config._config_file_override is None:
+        save_current_config()
+
+
+def main() -> None:
     if sys.platform == "win32":
         asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
     args = parse_arguments()
 
     if args.config:
-        apply_config_override(validate_config_file(args.config))
+        apply_config_override(args.config)
 
     check_docker_installed()
     pull_docker_image()
@@ -829,63 +529,28 @@ def main() -> None:
     validate_environment()
     asyncio.run(warm_up_llm())
 
-    persist_current()
+    persist_config()
 
-    args.run_name = args.resume or generate_run_name(args.targets_info)
+    args.run_name = generate_run_name(args.targets_info)
 
-    if not args.resume:
-        for target_info in args.targets_info:
-            if target_info["type"] == "repository":
-                repo_url = target_info["details"]["target_repo"]
-                dest_name = target_info["details"].get("workspace_subdir")
-                cloned_path = clone_repository(repo_url, args.run_name, dest_name)
-                target_info["details"]["cloned_repo_path"] = cloned_path
+    for target_info in args.targets_info:
+        if target_info["type"] == "repository":
+            repo_url = target_info["details"]["target_repo"]
+            dest_name = target_info["details"].get("workspace_subdir")
+            cloned_path = clone_repository(repo_url, args.run_name, dest_name)
+            target_info["details"]["cloned_repo_path"] = cloned_path
 
-        args.local_sources = collect_local_sources(args.targets_info)
-        try:
-            diff_scope = resolve_diff_scope_context(
-                local_sources=args.local_sources,
-                scope_mode=args.scope_mode,
-                diff_base=args.diff_base,
-                non_interactive=args.non_interactive,
-            )
-        except ValueError as e:
-            console = Console()
-            error_text = Text()
-            error_text.append("DIFF SCOPE RESOLUTION FAILED", style="bold red")
-            error_text.append("\n\n", style="white")
-            error_text.append(str(e), style="white")
+    args.local_sources = collect_local_sources(args.targets_info)
 
-            panel = Panel(
-                error_text,
-                title="[bold white]STRIX",
-                title_align="left",
-                border_style="red",
-                padding=(1, 2),
-            )
-            console.print("\n")
-            console.print(panel)
-            console.print()
-            sys.exit(1)
+    is_whitebox = bool(args.local_sources)
 
-        args.diff_scope = diff_scope.metadata
-        if diff_scope.instruction_block:
-            if args.instruction:
-                args.instruction = f"{diff_scope.instruction_block}\n\n{args.instruction}"
-            else:
-                args.instruction = diff_scope.instruction_block
-
-        _persist_run_record(args)
-
-    _telemetry_start_kwargs = {
-        "model": load_settings().llm.model,
-        "scan_mode": args.scan_mode,
-        "is_whitebox": is_whitebox_scan(args.targets_info),
-        "interactive": not args.non_interactive,
-        "has_instructions": bool(args.instruction),
-    }
-    posthog.start(**_telemetry_start_kwargs)
-    scarf.start(**_telemetry_start_kwargs)
+    posthog.start(
+        model=Config.get("strix_llm"),
+        scan_mode=args.scan_mode,
+        is_whitebox=is_whitebox,
+        interactive=not args.non_interactive,
+        has_instructions=bool(args.instruction),
+    )
 
     exit_reason = "user_exit"
     try:
@@ -895,28 +560,21 @@ def main() -> None:
             asyncio.run(run_tui(args))
     except KeyboardInterrupt:
         exit_reason = "interrupted"
-    except Exception:
+    except Exception as e:
         exit_reason = "error"
-        posthog.error("unhandled_exception")
-        scarf.error("unhandled_exception")
+        posthog.error("unhandled_exception", str(e))
         raise
     finally:
-        report_state = get_global_report_state()
-        if report_state:
-            status = {"interrupted": "interrupted", "error": "failed"}.get(
-                exit_reason,
-                "stopped",
-            )
-            report_state.cleanup(status=status)
-            posthog.end(report_state, exit_reason=exit_reason)
-            scarf.end(report_state, exit_reason=exit_reason)
+        tracer = get_global_tracer()
+        if tracer:
+            posthog.end(tracer, exit_reason=exit_reason)
 
-    results_path = run_dir_for(args.run_name)
+    results_path = Path("strix_runs") / args.run_name
     display_completion_message(args, results_path)
 
     if args.non_interactive:
-        report_state = get_global_report_state()
-        if report_state and report_state.vulnerability_reports:
+        tracer = get_global_tracer()
+        if tracer and tracer.vulnerability_reports:
             sys.exit(2)
 
 

strix/interface/streaming_parser.py

@@ -0,0 +1,125 @@
+import html
+import re
+from dataclasses import dataclass
+from typing import Literal
+
+from strix.llm.utils import normalize_tool_format
+
+
+_FUNCTION_TAG_PREFIX = "<function="
+_INVOKE_TAG_PREFIX = "<invoke "
+
+_FUNC_PATTERN = re.compile(r"<function=([^>]+)>")
+_FUNC_END_PATTERN = re.compile(r"</function>")
+_COMPLETE_PARAM_PATTERN = re.compile(r"<parameter=([^>]+)>(.*?)</parameter>", re.DOTALL)
+_INCOMPLETE_PARAM_PATTERN = re.compile(r"<parameter=([^>]+)>(.*)$", re.DOTALL)
+
+
+def _get_safe_content(content: str) -> tuple[str, str]:
+    if not content:
+        return "", ""
+
+    last_lt = content.rfind("<")
+    if last_lt == -1:
+        return content, ""
+
+    suffix = content[last_lt:]
+
+    if _FUNCTION_TAG_PREFIX.startswith(suffix) or _INVOKE_TAG_PREFIX.startswith(suffix):
+        return content[:last_lt], suffix
+
+    return content, ""
+
+
+@dataclass
+class StreamSegment:
+    type: Literal["text", "tool"]
+    content: str
+    tool_name: str | None = None
+    args: dict[str, str] | None = None
+    is_complete: bool = False
+
+
+def parse_streaming_content(content: str) -> list[StreamSegment]:
+    if not content:
+        return []
+
+    content = normalize_tool_format(content)
+
+    segments: list[StreamSegment] = []
+
+    func_matches = list(_FUNC_PATTERN.finditer(content))
+
+    if not func_matches:
+        safe_content, _ = _get_safe_content(content)
+        text = safe_content.strip()
+        if text:
+            segments.append(StreamSegment(type="text", content=text))
+        return segments
+
+    first_func_start = func_matches[0].start()
+    if first_func_start > 0:
+        text_before = content[:first_func_start].strip()
+        if text_before:
+            segments.append(StreamSegment(type="text", content=text_before))
+
+    for i, match in enumerate(func_matches):
+        tool_name = match.group(1)
+        func_start = match.end()
+
+        func_end_match = _FUNC_END_PATTERN.search(content, func_start)
+
+        if func_end_match:
+            func_body = content[func_start : func_end_match.start()]
+            is_complete = True
+            end_pos = func_end_match.end()
+        else:
+            if i + 1 < len(func_matches):
+                next_func_start = func_matches[i + 1].start()
+                func_body = content[func_start:next_func_start]
+            else:
+                func_body = content[func_start:]
+            is_complete = False
+            end_pos = len(content)
+
+        args = _parse_streaming_params(func_body)
+
+        segments.append(
+            StreamSegment(
+                type="tool",
+                content=func_body,
+                tool_name=tool_name,
+                args=args,
+                is_complete=is_complete,
+            )
+        )
+
+        if is_complete and i + 1 < len(func_matches):
+            next_start = func_matches[i + 1].start()
+            text_between = content[end_pos:next_start].strip()
+            if text_between:
+                segments.append(StreamSegment(type="text", content=text_between))
+
+    return segments
+
+
+def _parse_streaming_params(func_body: str) -> dict[str, str]:
+    args: dict[str, str] = {}
+
+    complete_matches = list(_COMPLETE_PARAM_PATTERN.finditer(func_body))
+    complete_end_pos = 0
+
+    for match in complete_matches:
+        param_name = match.group(1)
+        param_value = html.unescape(match.group(2).strip())
+        args[param_name] = param_value
+        complete_end_pos = max(complete_end_pos, match.end())
+
+    remaining = func_body[complete_end_pos:]
+    incomplete_match = _INCOMPLETE_PARAM_PATTERN.search(remaining)
+    if incomplete_match:
+        param_name = incomplete_match.group(1)
+        param_value = html.unescape(incomplete_match.group(2).strip())
+        args[param_name] = param_value
+
+    return args

strix/interface/tool_components/__init__.py

@@ -0,0 +1,45 @@
+from . import (
+    agent_message_renderer,
+    agents_graph_renderer,
+    browser_renderer,
+    file_edit_renderer,
+    finish_renderer,
+    load_skill_renderer,
+    notes_renderer,
+    proxy_renderer,
+    python_renderer,
+    reporting_renderer,
+    scan_info_renderer,
+    terminal_renderer,
+    thinking_renderer,
+    todo_renderer,
+    user_message_renderer,
+    web_search_renderer,
+)
+from .base_renderer import BaseToolRenderer
+from .registry import ToolTUIRegistry, get_tool_renderer, register_tool_renderer, render_tool_widget
+
+
+__all__ = [
+    "BaseToolRenderer",
+    "ToolTUIRegistry",
+    "agent_message_renderer",
+    "agents_graph_renderer",
+    "browser_renderer",
+    "file_edit_renderer",
+    "finish_renderer",
+    "get_tool_renderer",
+    "load_skill_renderer",
+    "notes_renderer",
+    "proxy_renderer",
+    "python_renderer",
+    "register_tool_renderer",
+    "render_tool_widget",
+    "reporting_renderer",
+    "scan_info_renderer",
+    "terminal_renderer",
+    "thinking_renderer",
+    "todo_renderer",
+    "user_message_renderer",
+    "web_search_renderer",
+]

strix/interface/tool_components/agent_message_renderer.py

@@ -1,4 +1,3 @@
-import re
 from functools import cache
 from typing import Any, ClassVar
 
@@ -6,9 +5,10 @@ from pygments.lexers import get_lexer_by_name, guess_lexer
 from pygments.styles import get_style_by_name
 from pygments.util import ClassNotFound
 from rich.text import Text
+from textual.widgets import Static
 
-
-_BLANK_LINE_RUNS = re.compile(r"\n\s*\n")
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
 
 
 _HEADER_STYLES = [
@@ -160,21 +160,31 @@ def _process_inline_formatting(line: str) -> Text:
     return result
 
 
-class AgentMessageRenderer:
-    _cache: ClassVar[dict[str, Text]] = {}
+@register_tool_renderer
+class AgentMessageRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "agent_message"
+    css_classes: ClassVar[list[str]] = ["chat-message", "agent-message"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        content = tool_data.get("content", "")
+
+        if not content:
+            return Static(Text(), classes=" ".join(cls.css_classes))
+
+        styled_text = _apply_markdown_styles(content)
+
+        return Static(styled_text, classes=" ".join(cls.css_classes))
 
     @classmethod
     def render_simple(cls, content: str) -> Text:
         if not content:
             return Text()
-        cleaned = _BLANK_LINE_RUNS.sub("\n\n", content).strip()
+
+        from strix.llm.utils import clean_content
+
+        cleaned = clean_content(content)
         if not cleaned:
             return Text()
-        cached = cls._cache.get(cleaned)
-        if cached is not None:
-            return cached.copy()
-        rendered = _apply_markdown_styles(cleaned)
-        if len(cls._cache) > 100:
-            cls._cache.clear()
-        cls._cache[cleaned] = rendered
-        return rendered.copy()
+
+        return _apply_markdown_styles(cleaned)

strix/interface/tool_components/agents_graph_renderer.py

@@ -61,12 +61,12 @@ class SendMessageToAgentRenderer(BaseToolRenderer):
         status = tool_data.get("status", "unknown")
 
         message = args.get("message", "")
-        target_agent_id = args.get("target_agent_id", "")
+        agent_id = args.get("agent_id", "")
 
         text = Text()
         text.append("→ ", style="#60a5fa")
-        if target_agent_id:
-            text.append(f"to {target_agent_id}", style="dim")
+        if agent_id:
+            text.append(f"to {agent_id}", style="dim")
         else:
             text.append("sending message", style="dim")
 
@@ -138,38 +138,3 @@ class WaitForMessageRenderer(BaseToolRenderer):
 
         css_classes = cls.get_css_classes(status)
         return Static(text, classes=css_classes)
-
-
-@register_tool_renderer
-class StopAgentRenderer(BaseToolRenderer):
-    tool_name: ClassVar[str] = "stop_agent"
-    css_classes: ClassVar[list[str]] = ["tool-call", "agents-graph-tool"]
-
-    @classmethod
-    def render(cls, tool_data: dict[str, Any]) -> Static:
-        args = tool_data.get("args", {})
-        result = tool_data.get("result")
-        status = tool_data.get("status", "unknown")
-
-        target_agent_id = args.get("target_agent_id", "")
-        cascade = args.get("cascade", True)
-        reason = args.get("reason", "")
-
-        text = Text()
-        text.append("◼ ", style="#ef4444")
-        text.append("stopping", style="dim")
-        if target_agent_id:
-            text.append(f" {target_agent_id}", style="bold #ef4444")
-        if cascade:
-            text.append(" + descendants", style="dim italic")
-
-        if reason:
-            text.append("\n  ")
-            text.append(reason, style="dim")
-
-        if isinstance(result, dict) and result.get("success") is False and result.get("error"):
-            text.append("\n  ")
-            text.append(str(result["error"]), style="#ef4444")
-
-        css_classes = cls.get_css_classes(status)
-        return Static(text, classes=css_classes)

strix/interface/tool_components/base_renderer.py

@@ -0,0 +1,94 @@
+from abc import ABC, abstractmethod
+from typing import Any, ClassVar
+
+from rich.text import Text
+from textual.widgets import Static
+
+
+class BaseToolRenderer(ABC):
+    tool_name: ClassVar[str] = ""
+    css_classes: ClassVar[list[str]] = ["tool-call"]
+
+    @classmethod
+    @abstractmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        pass
+
+    @classmethod
+    def build_text(cls, tool_data: dict[str, Any]) -> Text:  # noqa: ARG003
+        return Text()
+
+    @classmethod
+    def create_static(cls, content: Text, status: str) -> Static:
+        css_classes = cls.get_css_classes(status)
+        return Static(content, classes=css_classes)
+
+    @classmethod
+    def status_icon(cls, status: str) -> tuple[str, str]:
+        icons = {
+            "running": ("● In progress...", "#f59e0b"),
+            "completed": ("✓ Done", "#22c55e"),
+            "failed": ("✗ Failed", "#dc2626"),
+            "error": ("✗ Error", "#dc2626"),
+        }
+        return icons.get(status, ("○ Unknown", "dim"))
+
+    @classmethod
+    def get_css_classes(cls, status: str) -> str:
+        base_classes = cls.css_classes.copy()
+        base_classes.append(f"status-{status}")
+        return " ".join(base_classes)
+
+    @classmethod
+    def text_with_style(cls, content: str, style: str | None = None) -> Text:
+        text = Text()
+        text.append(content, style=style)
+        return text
+
+    @classmethod
+    def text_icon_label(
+        cls,
+        icon: str,
+        label: str,
+        icon_style: str | None = None,
+        label_style: str | None = None,
+    ) -> Text:
+        text = Text()
+        text.append(icon, style=icon_style)
+        text.append(" ")
+        text.append(label, style=label_style)
+        return text
+
+    @classmethod
+    def text_header(
+        cls,
+        icon: str,
+        title: str,
+        subtitle: str = "",
+        title_style: str = "bold",
+        subtitle_style: str = "dim",
+    ) -> Text:
+        text = Text()
+        text.append(icon)
+        text.append(" ")
+        text.append(title, style=title_style)
+        if subtitle:
+            text.append(" ")
+            text.append(subtitle, style=subtitle_style)
+        return text
+
+    @classmethod
+    def text_key_value(
+        cls,
+        key: str,
+        value: str,
+        key_style: str = "dim",
+        value_style: str | None = None,
+        indent: int = 2,
+    ) -> Text:
+        text = Text()
+        text.append(" " * indent)
+        text.append(key, style=key_style)
+        text.append(": ")
+        text.append(value, style=value_style)
+        return text

strix/interface/tool_components/browser_renderer.py

@@ -0,0 +1,136 @@
+from functools import cache
+from typing import Any, ClassVar
+
+from pygments.lexers import get_lexer_by_name
+from pygments.styles import get_style_by_name
+from rich.text import Text
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
+
+
+@cache
+def _get_style_colors() -> dict[Any, str]:
+    style = get_style_by_name("native")
+    return {token: f"#{style_def['color']}" for token, style_def in style if style_def["color"]}
+
+
+@register_tool_renderer
+class BrowserRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "browser_action"
+    css_classes: ClassVar[list[str]] = ["tool-call", "browser-tool"]
+
+    SIMPLE_ACTIONS: ClassVar[dict[str, str]] = {
+        "back": "going back in browser history",
+        "forward": "going forward in browser history",
+        "scroll_down": "scrolling down",
+        "scroll_up": "scrolling up",
+        "refresh": "refreshing browser tab",
+        "close_tab": "closing browser tab",
+        "switch_tab": "switching browser tab",
+        "list_tabs": "listing browser tabs",
+        "view_source": "viewing page source",
+        "get_console_logs": "getting console logs",
+        "screenshot": "taking screenshot of browser tab",
+        "wait": "waiting...",
+        "close": "closing browser",
+    }
+
+    @classmethod
+    def _get_token_color(cls, token_type: Any) -> str | None:
+        colors = _get_style_colors()
+        while token_type:
+            if token_type in colors:
+                return colors[token_type]
+            token_type = token_type.parent
+        return None
+
+    @classmethod
+    def _highlight_js(cls, code: str) -> Text:
+        lexer = get_lexer_by_name("javascript")
+        text = Text()
+
+        for token_type, token_value in lexer.get_tokens(code):
+            if not token_value:
+                continue
+            color = cls._get_token_color(token_type)
+            text.append(token_value, style=color)
+
+        return text
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        status = tool_data.get("status", "unknown")
+
+        action = args.get("action", "")
+        content = cls._build_content(action, args)
+
+        css_classes = cls.get_css_classes(status)
+        return Static(content, classes=css_classes)
+
+    @classmethod
+    def _build_url_action(cls, text: Text, label: str, url: str | None, suffix: str = "") -> None:
+        text.append(label, style="#06b6d4")
+        if url:
+            text.append(url, style="#06b6d4")
+            if suffix:
+                text.append(suffix, style="#06b6d4")
+
+    @classmethod
+    def _build_content(cls, action: str, args: dict[str, Any]) -> Text:
+        text = Text()
+        text.append("🌐 ")
+
+        if action in cls.SIMPLE_ACTIONS:
+            text.append(cls.SIMPLE_ACTIONS[action], style="#06b6d4")
+            return text
+
+        url = args.get("url")
+
+        url_actions = {
+            "launch": ("launching ", " on browser" if url else "browser"),
+            "goto": ("navigating to ", ""),
+            "new_tab": ("opening tab ", ""),
+        }
+        if action in url_actions:
+            label, suffix = url_actions[action]
+            if action == "launch" and not url:
+                text.append("launching browser", style="#06b6d4")
+            else:
+                cls._build_url_action(text, label, url, suffix)
+            return text
+
+        click_actions = {
+            "click": "clicking",
+            "double_click": "double clicking",
+            "hover": "hovering",
+        }
+        if action in click_actions:
+            text.append(click_actions[action], style="#06b6d4")
+            return text
+
+        handlers: dict[str, tuple[str, str | None]] = {
+            "type": ("typing ", args.get("text")),
+            "press_key": ("pressing key ", args.get("key")),
+            "save_pdf": ("saving PDF to ", args.get("file_path")),
+        }
+        if action in handlers:
+            label, value = handlers[action]
+            text.append(label, style="#06b6d4")
+            if value:
+                text.append(str(value), style="#06b6d4")
+            return text
+
+        if action == "execute_js":
+            text.append("executing javascript", style="#06b6d4")
+            js_code = args.get("js_code")
+            if js_code:
+                text.append("\n")
+                text.append_text(cls._highlight_js(js_code))
+            return text
+
+        if action:
+            text.append(action, style="#06b6d4")
+        return text

strix/interface/tool_components/file_edit_renderer.py

@@ -0,0 +1,177 @@
+from functools import cache
+from typing import Any, ClassVar
+
+from pygments.lexers import get_lexer_by_name, get_lexer_for_filename
+from pygments.styles import get_style_by_name
+from pygments.util import ClassNotFound
+from rich.text import Text
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
+
+
+@cache
+def _get_style_colors() -> dict[Any, str]:
+    style = get_style_by_name("native")
+    return {token: f"#{style_def['color']}" for token, style_def in style if style_def["color"]}
+
+
+def _get_lexer_for_file(path: str) -> Any:
+    try:
+        return get_lexer_for_filename(path)
+    except ClassNotFound:
+        return get_lexer_by_name("text")
+
+
+@register_tool_renderer
+class StrReplaceEditorRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "str_replace_editor"
+    css_classes: ClassVar[list[str]] = ["tool-call", "file-edit-tool"]
+
+    @classmethod
+    def _get_token_color(cls, token_type: Any) -> str | None:
+        colors = _get_style_colors()
+        while token_type:
+            if token_type in colors:
+                return colors[token_type]
+            token_type = token_type.parent
+        return None
+
+    @classmethod
+    def _highlight_code(cls, code: str, path: str) -> Text:
+        lexer = _get_lexer_for_file(path)
+        text = Text()
+
+        for token_type, token_value in lexer.get_tokens(code):
+            if not token_value:
+                continue
+            color = cls._get_token_color(token_type)
+            text.append(token_value, style=color)
+
+        return text
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        result = tool_data.get("result")
+
+        command = args.get("command", "")
+        path = args.get("path", "")
+        old_str = args.get("old_str", "")
+        new_str = args.get("new_str", "")
+        file_text = args.get("file_text", "")
+
+        text = Text()
+
+        icons_and_labels = {
+            "view": ("◇ ", "read", "#10b981"),
+            "str_replace": ("◇ ", "edit", "#10b981"),
+            "create": ("◇ ", "create", "#10b981"),
+            "insert": ("◇ ", "insert", "#10b981"),
+            "undo_edit": ("◇ ", "undo", "#10b981"),
+        }
+
+        icon, label, color = icons_and_labels.get(command, ("◇ ", "file", "#10b981"))
+        text.append(icon, style=color)
+        text.append(label, style="dim")
+
+        if path:
+            path_display = path[-60:] if len(path) > 60 else path
+            text.append(" ")
+            text.append(path_display, style="dim")
+
+        if command == "str_replace" and (old_str or new_str):
+            if old_str:
+                highlighted_old = cls._highlight_code(old_str, path)
+                for line in highlighted_old.plain.split("\n"):
+                    text.append("\n")
+                    text.append("-", style="#ef4444")
+                    text.append(" ")
+                    text.append(line)
+
+            if new_str:
+                highlighted_new = cls._highlight_code(new_str, path)
+                for line in highlighted_new.plain.split("\n"):
+                    text.append("\n")
+                    text.append("+", style="#22c55e")
+                    text.append(" ")
+                    text.append(line)
+
+        elif command == "create" and file_text:
+            text.append("\n")
+            text.append_text(cls._highlight_code(file_text, path))
+
+        elif command == "insert" and new_str:
+            highlighted_new = cls._highlight_code(new_str, path)
+            for line in highlighted_new.plain.split("\n"):
+                text.append("\n")
+                text.append("+", style="#22c55e")
+                text.append(" ")
+                text.append(line)
+
+        elif isinstance(result, str) and result.strip():
+            text.append("\n  ")
+            text.append(result.strip(), style="dim")
+        elif not (result and isinstance(result, dict) and "content" in result) and not path:
+            text.append(" ")
+            text.append("Processing...", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class ListFilesRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "list_files"
+    css_classes: ClassVar[list[str]] = ["tool-call", "file-edit-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        path = args.get("path", "")
+
+        text = Text()
+        text.append("◇ ", style="#10b981")
+        text.append("list", style="dim")
+        text.append(" ")
+
+        if path:
+            path_display = path[-60:] if len(path) > 60 else path
+            text.append(path_display, style="dim")
+        else:
+            text.append("Current directory", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class SearchFilesRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "search_files"
+    css_classes: ClassVar[list[str]] = ["tool-call", "file-edit-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        path = args.get("path", "")
+        regex = args.get("regex", "")
+
+        text = Text()
+        text.append("◇ ", style="#a855f7")
+        text.append("search", style="dim")
+        text.append("  ")
+
+        if path and regex:
+            text.append(path, style="dim")
+            text.append(" ", style="dim")
+            text.append(regex, style="#a855f7")
+        elif path:
+            text.append(path, style="dim")
+        elif regex:
+            text.append(regex, style="#a855f7")
+        else:
+            text.append("...", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)

strix/interface/tool_components/load_skill_renderer.py

@@ -17,11 +17,7 @@ class LoadSkillRenderer(BaseToolRenderer):
         args = tool_data.get("args", {})
         status = tool_data.get("status", "completed")
 
-        raw_skills = args.get("skills", "")
-        if isinstance(raw_skills, list):
-            requested = ", ".join(str(s) for s in raw_skills)
-        else:
-            requested = str(raw_skills)
+        requested = args.get("skills", "")
 
         text = Text()
         text.append("◇ ", style="#10b981")

strix/interface/tool_components/notes_renderer.py

@@ -117,8 +117,6 @@ class ListNotesRenderer(BaseToolRenderer):
                     title = note.get("title", "").strip() or "(untitled)"
                     category = note.get("category", "general")
                     note_content = note.get("content", "").strip()
-                    if not note_content:
-                        note_content = note.get("content_preview", "").strip()
 
                     text.append("\n  - ")
                     text.append(title)
@@ -133,35 +131,3 @@ class ListNotesRenderer(BaseToolRenderer):
 
         css_classes = cls.get_css_classes("completed")
         return Static(text, classes=css_classes)
-
-
-@register_tool_renderer
-class GetNoteRenderer(BaseToolRenderer):
-    tool_name: ClassVar[str] = "get_note"
-    css_classes: ClassVar[list[str]] = ["tool-call", "notes-tool"]
-
-    @classmethod
-    def render(cls, tool_data: dict[str, Any]) -> Static:
-        result = tool_data.get("result")
-
-        text = Text()
-        text.append("◇ ", style="#fbbf24")
-        text.append("note read", style="dim")
-
-        if result and isinstance(result, dict) and result.get("success"):
-            note = result.get("note", {}) or {}
-            title = str(note.get("title", "")).strip() or "(untitled)"
-            category = note.get("category", "general")
-            content = str(note.get("content", "")).strip()
-            text.append("\n  ")
-            text.append(title)
-            text.append(f" ({category})", style="dim")
-            if content:
-                text.append("\n  ")
-                text.append(content, style="dim")
-        else:
-            text.append("\n  ")
-            text.append("Loading...", style="dim")
-
-        css_classes = cls.get_css_classes("completed")
-        return Static(text, classes=css_classes)

strix/interface/tool_components/proxy_renderer.py

@@ -17,6 +17,7 @@ def _truncate(text: str, max_len: int = 80) -> str:
 
 
 def _sanitize(text: str, max_len: int = 150) -> str:
+    """Remove newlines and truncate text."""
     clean = text.replace("\n", " ").replace("\r", "").replace("\t", " ")
     return _truncate(clean, max_len)
 
@@ -41,7 +42,7 @@ class ListRequestsRenderer(BaseToolRenderer):
     css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
 
     @classmethod
-    def render(cls, tool_data: dict[str, Any]) -> Static:  # noqa: PLR0912, PLR0915
+    def render(cls, tool_data: dict[str, Any]) -> Static:  # noqa: PLR0912  # noqa: PLR0912
         args = tool_data.get("args", {})
         result = tool_data.get("result")
         status = tool_data.get("status", "running")
@@ -72,25 +73,21 @@ class ListRequestsRenderer(BaseToolRenderer):
             if "error" in result:
                 text.append(f"  error: {_sanitize(str(result['error']), 150)}", style="#ef4444")
             else:
-                entries = result.get("entries", [])
-                page_info = result.get("page_info") or {}
-                has_more = (
-                    bool(page_info.get("has_next_page")) if isinstance(page_info, dict) else False
-                )
-                count_suffix = "+" if has_more else ""
-                text.append(f"  [{len(entries)}{count_suffix} found]", style="dim")
+                total = result.get("total_count", 0)
+                requests = result.get("requests", [])
 
-                if entries and isinstance(entries, list):
+                text.append(f"  [{total} found]", style="dim")
+
+                if requests and isinstance(requests, list):
                     text.append("\n")
-                    for i, entry in enumerate(entries[:MAX_REQUESTS_DISPLAY]):
-                        if not isinstance(entry, dict):
+                    for i, req in enumerate(requests[:MAX_REQUESTS_DISPLAY]):
+                        if not isinstance(req, dict):
                             continue
-                        req = entry.get("request") or {}
-                        resp = entry.get("response") or {}
-                        method = req.get("method", "?") if isinstance(req, dict) else "?"
-                        host = req.get("host", "") if isinstance(req, dict) else ""
-                        path = req.get("path", "/") if isinstance(req, dict) else "/"
-                        code = resp.get("status_code") if isinstance(resp, dict) else None
+                        method = req.get("method", "?")
+                        host = req.get("host", "")
+                        path = req.get("path", "/")
+                        resp = req.get("response") or {}
+                        code = resp.get("statusCode") if isinstance(resp, dict) else None
 
                         text.append("  ")
                         text.append(f"{method:6}", style="#a78bfa")
@@ -98,13 +95,13 @@ class ListRequestsRenderer(BaseToolRenderer):
                         if code:
                             text.append(f" {code}", style=_status_style(code))
 
-                        if i < min(len(entries), MAX_REQUESTS_DISPLAY) - 1:
+                        if i < min(len(requests), MAX_REQUESTS_DISPLAY) - 1:
                             text.append("\n")
 
-                    if len(entries) > MAX_REQUESTS_DISPLAY:
+                    if len(requests) > MAX_REQUESTS_DISPLAY:
                         text.append("\n")
                         text.append(
-                            f"  ... +{len(entries) - MAX_REQUESTS_DISPLAY} more",
+                            f"  ... +{len(requests) - MAX_REQUESTS_DISPLAY} more",
                             style="dim italic",
                         )
 
@@ -142,14 +139,14 @@ class ViewRequestRenderer(BaseToolRenderer):
         if status == "completed" and isinstance(result, dict):
             if "error" in result:
                 text.append(f"  error: {_sanitize(str(result['error']), 150)}", style="#ef4444")
-            elif "hits" in result:
-                hits = result.get("hits", [])
-                total = result.get("total_hits", len(hits))
+            elif "matches" in result:
+                matches = result.get("matches", [])
+                total = result.get("total_matches", len(matches))
                 text.append(f"  [{total} matches]", style="dim")
 
-                if hits and isinstance(hits, list):
+                if matches and isinstance(matches, list):
                     text.append("\n")
-                    for i, m in enumerate(hits[:5]):
+                    for i, m in enumerate(matches[:5]):
                         if not isinstance(m, dict):
                             continue
                         before = m.get("before", "") or ""
@@ -167,20 +164,19 @@ class ViewRequestRenderer(BaseToolRenderer):
                         if after:
                             text.append(f"{after}...", style="dim")
 
-                        if i < min(len(hits), 5) - 1:
+                        if i < min(len(matches), 5) - 1:
                             text.append("\n")
 
-                    if len(hits) > 5:
+                    if len(matches) > 5:
                         text.append("\n")
-                        text.append(f"  ... +{len(hits) - 5} more matches", style="dim italic")
+                        text.append(f"  ... +{len(matches) - 5} more matches", style="dim italic")
 
             elif "content" in result:
-                page = result.get("page", 1)
-                total_lines = result.get("total_lines", 0)
+                showing = result.get("showing_lines", "")
                 has_more = result.get("has_more", False)
                 content = result.get("content", "")
 
-                text.append(f"  [page {page}, {total_lines} lines]", style="dim")
+                text.append(f"  [{showing}]", style="dim")
 
                 if content and isinstance(content, str):
                     lines = content.split("\n")[:15]
@@ -191,7 +187,7 @@ class ViewRequestRenderer(BaseToolRenderer):
                         if i < len(lines) - 1:
                             text.append("\n")
 
-                    if has_more or len(content.split("\n")) > 15:
+                    if has_more or len(lines) > 15:
                         text.append("\n")
                         text.append("  ... more content available", style="dim italic")
 
@@ -199,6 +195,80 @@ class ViewRequestRenderer(BaseToolRenderer):
         return Static(text, classes=css_classes)
 
 
+@register_tool_renderer
+class SendRequestRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "send_request"
+    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:  # noqa: PLR0912, PLR0915
+        args = tool_data.get("args", {})
+        result = tool_data.get("result")
+        status = tool_data.get("status", "running")
+
+        method = args.get("method", "GET")
+        url = args.get("url", "")
+        req_headers = args.get("headers")
+        req_body = args.get("body", "")
+
+        text = Text()
+        text.append(PROXY_ICON, style="dim")
+        text.append(" sending request", style="#06b6d4")
+
+        text.append("\n")
+        text.append("  >> ", style="#3b82f6")
+        text.append(method, style="#a78bfa")
+        text.append(f" {_truncate(url, 180)}", style="dim")
+
+        if req_headers and isinstance(req_headers, dict):
+            for k, v in list(req_headers.items())[:5]:
+                text.append("\n")
+                text.append("  >> ", style="#3b82f6")
+                text.append(f"{k}: ", style="dim")
+                text.append(_sanitize(str(v), 150), style="dim")
+
+        if req_body and isinstance(req_body, str):
+            text.append("\n")
+            text.append("  >> ", style="#3b82f6")
+            body_lines = req_body.split("\n")[:4]
+            for i, line in enumerate(body_lines):
+                if i > 0:
+                    text.append("\n")
+                    text.append("     ", style="dim")
+                text.append(_truncate(line, MAX_LINE_LENGTH), style="dim")
+            if len(req_body.split("\n")) > 4:
+                text.append(" ...", style="dim italic")
+
+        if status == "completed" and isinstance(result, dict):
+            if "error" in result:
+                text.append(f"\n  error: {_sanitize(str(result['error']), 150)}", style="#ef4444")
+            else:
+                code = result.get("status_code")
+                time_ms = result.get("response_time_ms")
+
+                text.append("\n")
+                text.append("  << ", style="#22c55e")
+                if code:
+                    text.append(f"{code}", style=_status_style(code))
+                if time_ms:
+                    text.append(f" ({time_ms}ms)", style="dim")
+
+                body = result.get("body", "")
+                if body and isinstance(body, str):
+                    lines = body.split("\n")[:6]
+                    for line in lines:
+                        text.append("\n")
+                        text.append("  << ", style="#22c55e")
+                        text.append(_truncate(line, MAX_LINE_LENGTH - 5), style="dim")
+
+                    if len(body.split("\n")) > 6:
+                        text.append("\n")
+                        text.append("  ...", style="dim italic")
+
+        css_classes = cls.get_css_classes(status)
+        return Static(text, classes=css_classes)
+
+
 @register_tool_renderer
 class RepeatRequestRenderer(BaseToolRenderer):
     tool_name: ClassVar[str] = "repeat_request"
@@ -262,26 +332,30 @@ class RepeatRequestRenderer(BaseToolRenderer):
             text.append(f"\n  {_truncate(modifications, 200)}", style="dim italic")
 
         if status == "completed" and isinstance(result, dict):
-            if not result.get("success", True) and result.get("error"):
+            if "error" in result:
                 text.append(f"\n  error: {_sanitize(str(result['error']), 150)}", style="#ef4444")
             else:
-                elapsed_ms = result.get("elapsed_ms")
-                response = result.get("response") or {}
-                code = response.get("status_code") if isinstance(response, dict) else None
-                body = response.get("body", "") if isinstance(response, dict) else ""
-                body_truncated = (
-                    bool(response.get("body_truncated")) if isinstance(response, dict) else False
-                )
+                req = result.get("request", {})
+                method = req.get("method", "")
+                url = req.get("url", "")
+                code = result.get("status_code")
+                time_ms = result.get("response_time_ms")
+
+                text.append("\n")
+                text.append("  >> ", style="#3b82f6")
+                if method:
+                    text.append(f"{method} ", style="#a78bfa")
+                if url:
+                    text.append(_truncate(url, 180), style="dim")
 
                 text.append("\n")
                 text.append("  << ", style="#22c55e")
                 if code:
                     text.append(f"{code}", style=_status_style(code))
-                else:
-                    text.append("(no response)", style="dim")
-                if elapsed_ms:
-                    text.append(f" ({elapsed_ms}ms)", style="dim")
+                if time_ms:
+                    text.append(f" ({time_ms}ms)", style="dim")
 
+                body = result.get("body", "")
                 if body and isinstance(body, str):
                     lines = body.split("\n")[:5]
                     for line in lines:
@@ -289,7 +363,7 @@ class RepeatRequestRenderer(BaseToolRenderer):
                         text.append("  << ", style="#22c55e")
                         text.append(_truncate(line, MAX_LINE_LENGTH - 5), style="dim")
 
-                    if body_truncated or len(body.split("\n")) > 5:
+                    if len(body.split("\n")) > 5:
                         text.append("\n")
                         text.append("  ...", style="dim italic")
 
@@ -297,155 +371,6 @@ class RepeatRequestRenderer(BaseToolRenderer):
         return Static(text, classes=css_classes)
 
 
-@register_tool_renderer
-class ListSitemapRenderer(BaseToolRenderer):
-    tool_name: ClassVar[str] = "list_sitemap"
-    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
-
-    @classmethod
-    def render(cls, tool_data: dict[str, Any]) -> Static:  # noqa: PLR0912, PLR0915
-        args = tool_data.get("args", {})
-        result = tool_data.get("result")
-        status = tool_data.get("status", "running")
-
-        parent_id = args.get("parent_id")
-        scope_id = args.get("scope_id")
-        depth = args.get("depth")
-
-        text = Text()
-        text.append(PROXY_ICON, style="dim")
-        text.append(" listing sitemap", style="#06b6d4")
-
-        if parent_id:
-            text.append(f"  under #{_truncate(str(parent_id), 20)}", style="dim")
-
-        meta_parts = []
-        if scope_id and isinstance(scope_id, str):
-            meta_parts.append(f"scope:{scope_id[:8]}")
-        if depth and depth != "DIRECT":
-            meta_parts.append(depth.lower())
-        if meta_parts:
-            text.append(f"  ({', '.join(meta_parts)})", style="dim")
-
-        if status == "completed" and isinstance(result, dict):
-            if "error" in result:
-                text.append(f"  error: {_sanitize(str(result['error']), 150)}", style="#ef4444")
-            else:
-                total = result.get("total_count", 0)
-                entries = result.get("entries", [])
-
-                text.append(f"  [{total} entries]", style="dim")
-
-                if entries and isinstance(entries, list):
-                    text.append("\n")
-                    for i, entry in enumerate(entries[:MAX_REQUESTS_DISPLAY]):
-                        if not isinstance(entry, dict):
-                            continue
-                        kind = entry.get("kind") or "?"
-                        label = entry.get("label") or "?"
-                        has_children = entry.get("has_descendants", False)
-                        req = entry.get("request") or {}
-
-                        kind_style = {
-                            "DOMAIN": "#f59e0b",
-                            "DIRECTORY": "#3b82f6",
-                            "REQUEST": "#22c55e",
-                        }.get(kind, "dim")
-
-                        text.append("  ")
-                        kind_abbr = kind[:3] if isinstance(kind, str) else "?"
-                        text.append(f"{kind_abbr:3}", style=kind_style)
-                        text.append(f" {_truncate(label, 150)}", style="dim")
-
-                        if req:
-                            method = req.get("method", "")
-                            code = req.get("status_code")
-                            if method:
-                                text.append(f" {method}", style="#a78bfa")
-                            if code:
-                                text.append(f" {code}", style=_status_style(code))
-
-                        if has_children:
-                            text.append(" +", style="dim italic")
-
-                        if i < min(len(entries), MAX_REQUESTS_DISPLAY) - 1:
-                            text.append("\n")
-
-                    if len(entries) > MAX_REQUESTS_DISPLAY:
-                        text.append("\n")
-                        text.append(
-                            f"  ... +{len(entries) - MAX_REQUESTS_DISPLAY} more", style="dim italic"
-                        )
-
-        css_classes = cls.get_css_classes(status)
-        return Static(text, classes=css_classes)
-
-
-@register_tool_renderer
-class ViewSitemapEntryRenderer(BaseToolRenderer):
-    tool_name: ClassVar[str] = "view_sitemap_entry"
-    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
-
-    @classmethod
-    def render(cls, tool_data: dict[str, Any]) -> Static:  # noqa: PLR0912
-        args = tool_data.get("args", {})
-        result = tool_data.get("result")
-        status = tool_data.get("status", "running")
-
-        entry_id = args.get("entry_id", "")
-
-        text = Text()
-        text.append(PROXY_ICON, style="dim")
-        text.append(" viewing sitemap", style="#06b6d4")
-
-        if entry_id:
-            text.append(f" #{_truncate(str(entry_id), 20)}", style="dim")
-
-        if status == "completed" and isinstance(result, dict):
-            if "error" in result:
-                text.append(f"  error: {_sanitize(str(result['error']), 150)}", style="#ef4444")
-            elif "entry" in result:
-                entry = result.get("entry") or {}
-                if not isinstance(entry, dict):
-                    entry = {}
-                kind = entry.get("kind", "")
-                label = entry.get("label", "")
-                related = entry.get("related_requests") or {}
-                related_reqs = related.get("requests", []) if isinstance(related, dict) else []
-                total_related = related.get("total_count", 0) if isinstance(related, dict) else 0
-
-                if kind and label:
-                    text.append(f"  {kind}: {_truncate(label, 120)}", style="dim")
-
-                if total_related:
-                    text.append(f"  [{total_related} requests]", style="dim")
-
-                if related_reqs and isinstance(related_reqs, list):
-                    text.append("\n")
-                    for i, req in enumerate(related_reqs[:10]):
-                        if not isinstance(req, dict):
-                            continue
-                        method = req.get("method", "?")
-                        path = req.get("path", "/")
-                        code = req.get("status_code")
-
-                        text.append("  ")
-                        text.append(f"{method:6}", style="#a78bfa")
-                        text.append(f" {_truncate(path, 180)}", style="dim")
-                        if code:
-                            text.append(f" {code}", style=_status_style(code))
-
-                        if i < min(len(related_reqs), 10) - 1:
-                            text.append("\n")
-
-                    if len(related_reqs) > 10:
-                        text.append("\n")
-                        text.append(f"  ... +{len(related_reqs) - 10} more", style="dim italic")
-
-        css_classes = cls.get_css_classes(status)
-        return Static(text, classes=css_classes)
-
-
 @register_tool_renderer
 class ScopeRulesRenderer(BaseToolRenderer):
     tool_name: ClassVar[str] = "scope_rules"
@@ -534,3 +459,152 @@ class ScopeRulesRenderer(BaseToolRenderer):
 
         css_classes = cls.get_css_classes(status)
         return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class ListSitemapRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "list_sitemap"
+    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:  # noqa: PLR0912, PLR0915
+        args = tool_data.get("args", {})
+        result = tool_data.get("result")
+        status = tool_data.get("status", "running")
+
+        parent_id = args.get("parent_id")
+        scope_id = args.get("scope_id")
+        depth = args.get("depth")
+
+        text = Text()
+        text.append(PROXY_ICON, style="dim")
+        text.append(" listing sitemap", style="#06b6d4")
+
+        if parent_id:
+            text.append(f"  under #{_truncate(str(parent_id), 20)}", style="dim")
+
+        meta_parts = []
+        if scope_id and isinstance(scope_id, str):
+            meta_parts.append(f"scope:{scope_id[:8]}")
+        if depth and depth != "DIRECT":
+            meta_parts.append(depth.lower())
+        if meta_parts:
+            text.append(f"  ({', '.join(meta_parts)})", style="dim")
+
+        if status == "completed" and isinstance(result, dict):
+            if "error" in result:
+                text.append(f"  error: {_sanitize(str(result['error']), 150)}", style="#ef4444")
+            else:
+                total = result.get("total_count", 0)
+                entries = result.get("entries", [])
+
+                text.append(f"  [{total} entries]", style="dim")
+
+                if entries and isinstance(entries, list):
+                    text.append("\n")
+                    for i, entry in enumerate(entries[:MAX_REQUESTS_DISPLAY]):
+                        if not isinstance(entry, dict):
+                            continue
+                        kind = entry.get("kind") or "?"
+                        label = entry.get("label") or "?"
+                        has_children = entry.get("hasDescendants", False)
+                        req = entry.get("request") or {}
+
+                        kind_style = {
+                            "DOMAIN": "#f59e0b",
+                            "DIRECTORY": "#3b82f6",
+                            "REQUEST": "#22c55e",
+                        }.get(kind, "dim")
+
+                        text.append("  ")
+                        kind_abbr = kind[:3] if isinstance(kind, str) else "?"
+                        text.append(f"{kind_abbr:3}", style=kind_style)
+                        text.append(f" {_truncate(label, 150)}", style="dim")
+
+                        if req:
+                            method = req.get("method", "")
+                            code = req.get("status")
+                            if method:
+                                text.append(f" {method}", style="#a78bfa")
+                            if code:
+                                text.append(f" {code}", style=_status_style(code))
+
+                        if has_children:
+                            text.append(" +", style="dim italic")
+
+                        if i < min(len(entries), MAX_REQUESTS_DISPLAY) - 1:
+                            text.append("\n")
+
+                    if len(entries) > MAX_REQUESTS_DISPLAY:
+                        text.append("\n")
+                        text.append(
+                            f"  ... +{len(entries) - MAX_REQUESTS_DISPLAY} more", style="dim italic"
+                        )
+
+        css_classes = cls.get_css_classes(status)
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class ViewSitemapEntryRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "view_sitemap_entry"
+    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:  # noqa: PLR0912
+        args = tool_data.get("args", {})
+        result = tool_data.get("result")
+        status = tool_data.get("status", "running")
+
+        entry_id = args.get("entry_id", "")
+
+        text = Text()
+        text.append(PROXY_ICON, style="dim")
+        text.append(" viewing sitemap", style="#06b6d4")
+
+        if entry_id:
+            text.append(f" #{_truncate(str(entry_id), 20)}", style="dim")
+
+        if status == "completed" and isinstance(result, dict):
+            if "error" in result:
+                text.append(f"  error: {_sanitize(str(result['error']), 150)}", style="#ef4444")
+            elif "entry" in result:
+                entry = result.get("entry") or {}
+                if not isinstance(entry, dict):
+                    entry = {}
+                kind = entry.get("kind", "")
+                label = entry.get("label", "")
+                related = entry.get("related_requests") or {}
+                related_reqs = related.get("requests", []) if isinstance(related, dict) else []
+                total_related = related.get("total_count", 0) if isinstance(related, dict) else 0
+
+                if kind and label:
+                    text.append(f"  {kind}: {_truncate(label, 120)}", style="dim")
+
+                if total_related:
+                    text.append(f"  [{total_related} requests]", style="dim")
+
+                if related_reqs and isinstance(related_reqs, list):
+                    text.append("\n")
+                    for i, req in enumerate(related_reqs[:10]):
+                        if not isinstance(req, dict):
+                            continue
+                        method = req.get("method", "?")
+                        path = req.get("path", "/")
+                        code = req.get("status")
+
+                        text.append("  ")
+                        text.append(f"{method:6}", style="#a78bfa")
+                        text.append(f" {_truncate(path, 180)}", style="dim")
+                        if code:
+                            text.append(f" {code}", style=_status_style(code))
+
+                        if i < min(len(related_reqs), 10) - 1:
+                            text.append("\n")
+
+                    if len(related_reqs) > 10:
+                        text.append("\n")
+                        text.append(f"  ... +{len(related_reqs) - 10} more", style="dim italic")
+
+        css_classes = cls.get_css_classes(status)
+        return Static(text, classes=css_classes)

strix/interface/tool_components/python_renderer.py

@@ -0,0 +1,155 @@
+import re
+from functools import cache
+from typing import Any, ClassVar
+
+from pygments.lexers import PythonLexer
+from pygments.styles import get_style_by_name
+from rich.text import Text
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
+
+
+MAX_OUTPUT_LINES = 50
+MAX_LINE_LENGTH = 200
+
+ANSI_PATTERN = re.compile(r"\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*\x07)")
+
+STRIP_PATTERNS = [
+    r"\.\.\. \[(stdout|stderr|result|output|error) truncated at \d+k? chars\]",
+]
+
+
+@cache
+def _get_style_colors() -> dict[Any, str]:
+    style = get_style_by_name("native")
+    return {token: f"#{style_def['color']}" for token, style_def in style if style_def["color"]}
+
+
+@cache
+def _get_lexer() -> PythonLexer:
+    return PythonLexer()
+
+
+@cache
+def _get_token_color(token_type: Any) -> str | None:
+    colors = _get_style_colors()
+    while token_type:
+        if token_type in colors:
+            return colors[token_type]
+        token_type = token_type.parent
+    return None
+
+
+@register_tool_renderer
+class PythonRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "python_action"
+    css_classes: ClassVar[list[str]] = ["tool-call", "python-tool"]
+
+    @classmethod
+    def _highlight_python(cls, code: str) -> Text:
+        text = Text()
+        for token_type, token_value in _get_lexer().get_tokens(code):
+            if token_value:
+                text.append(token_value, style=_get_token_color(token_type))
+        return text
+
+    @classmethod
+    def _clean_output(cls, output: str) -> str:
+        cleaned = output
+        for pattern in STRIP_PATTERNS:
+            cleaned = re.sub(pattern, "", cleaned)
+        return cleaned.strip()
+
+    @classmethod
+    def _strip_ansi(cls, text: str) -> str:
+        return ANSI_PATTERN.sub("", text)
+
+    @classmethod
+    def _truncate_line(cls, line: str) -> str:
+        clean_line = cls._strip_ansi(line)
+        if len(clean_line) > MAX_LINE_LENGTH:
+            return clean_line[: MAX_LINE_LENGTH - 3] + "..."
+        return clean_line
+
+    @classmethod
+    def _format_output(cls, output: str) -> Text:
+        text = Text()
+        lines = output.splitlines()
+        total_lines = len(lines)
+
+        head_count = MAX_OUTPUT_LINES // 2
+        tail_count = MAX_OUTPUT_LINES - head_count - 1
+
+        if total_lines <= MAX_OUTPUT_LINES:
+            display_lines = lines
+            truncated = False
+            hidden_count = 0
+        else:
+            display_lines = lines[:head_count]
+            truncated = True
+            hidden_count = total_lines - head_count - tail_count
+
+        for i, line in enumerate(display_lines):
+            truncated_line = cls._truncate_line(line)
+            text.append("  ")
+            text.append(truncated_line, style="dim")
+            if i < len(display_lines) - 1 or truncated:
+                text.append("\n")
+
+        if truncated:
+            text.append(f"  ... {hidden_count} lines truncated ...", style="dim italic")
+            text.append("\n")
+            tail_lines = lines[-tail_count:]
+            for i, line in enumerate(tail_lines):
+                truncated_line = cls._truncate_line(line)
+                text.append("  ")
+                text.append(truncated_line, style="dim")
+                if i < len(tail_lines) - 1:
+                    text.append("\n")
+
+        return text
+
+    @classmethod
+    def _append_output(cls, text: Text, result: dict[str, Any] | str) -> None:
+        if isinstance(result, str):
+            if result.strip():
+                text.append("\n")
+                text.append_text(cls._format_output(result))
+            return
+
+        stdout = result.get("stdout", "")
+        stdout = cls._clean_output(stdout) if stdout else ""
+
+        if stdout:
+            text.append("\n")
+            formatted_output = cls._format_output(stdout)
+            text.append_text(formatted_output)
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        status = tool_data.get("status", "unknown")
+        result = tool_data.get("result")
+
+        action = args.get("action", "")
+        code = args.get("code", "")
+
+        text = Text()
+        text.append("</> ", style="dim")
+
+        if code and action in ["new_session", "execute"]:
+            text.append_text(cls._highlight_python(code))
+        elif action == "close":
+            text.append("Closing session...", style="dim")
+        elif action == "list_sessions":
+            text.append("Listing sessions...", style="dim")
+        else:
+            text.append("Running...", style="dim")
+
+        if result and isinstance(result, dict | str):
+            cls._append_output(text, result)
+
+        css_classes = cls.get_css_classes(status)
+        return Static(text, classes=css_classes)

strix/interface/tool_components/registry.py

@@ -20,6 +20,14 @@ class ToolTUIRegistry:
     def get_renderer(cls, tool_name: str) -> type[BaseToolRenderer] | None:
         return cls._renderers.get(tool_name)
 
+    @classmethod
+    def list_tools(cls) -> list[str]:
+        return list(cls._renderers.keys())
+
+    @classmethod
+    def has_renderer(cls, tool_name: str) -> bool:
+        return tool_name in cls._renderers
+
 
 def register_tool_renderer(renderer_class: type[BaseToolRenderer]) -> type[BaseToolRenderer]:
     ToolTUIRegistry.register(renderer_class)

strix/interface/tool_components/reporting_renderer.py

@@ -6,22 +6,15 @@ from pygments.styles import get_style_by_name
 from rich.text import Text
 from textual.widgets import Static
 
+from strix.tools.reporting.reporting_actions import (
+    parse_code_locations_xml,
+    parse_cvss_xml,
+)
+
 from .base_renderer import BaseToolRenderer
 from .registry import register_tool_renderer
 
 
-def _coerce_dict(value: Any) -> dict[str, Any]:
-    if isinstance(value, dict):
-        return value
-    return {}
-
-
-def _coerce_list_of_dicts(value: Any) -> list[dict[str, Any]]:
-    if isinstance(value, list):
-        return [item for item in value if isinstance(item, dict)]
-    return []
-
-
 @cache
 def _get_style_colors() -> dict[Any, str]:
     style = get_style_by_name("native")
@@ -99,8 +92,8 @@ class CreateVulnerabilityReportRenderer(BaseToolRenderer):
         poc_script_code = args.get("poc_script_code", "")
         remediation_steps = args.get("remediation_steps", "")
 
-        cvss_breakdown = _coerce_dict(args.get("cvss_breakdown"))
-        code_locations = _coerce_list_of_dicts(args.get("code_locations"))
+        cvss_breakdown_xml = args.get("cvss_breakdown", "")
+        code_locations_xml = args.get("code_locations", "")
 
         endpoint = args.get("endpoint", "")
         method = args.get("method", "")
@@ -159,7 +152,8 @@ class CreateVulnerabilityReportRenderer(BaseToolRenderer):
             text.append("CWE: ", style=FIELD_STYLE)
             text.append(cwe)
 
-        if cvss_breakdown:
+        parsed_cvss = parse_cvss_xml(cvss_breakdown_xml) if cvss_breakdown_xml else None
+        if parsed_cvss:
             text.append("\n\n")
             cvss_parts = []
             for key, prefix in [
@@ -172,7 +166,7 @@ class CreateVulnerabilityReportRenderer(BaseToolRenderer):
                 ("integrity", "I"),
                 ("availability", "A"),
             ]:
-                val = cvss_breakdown.get(key)
+                val = parsed_cvss.get(key)
                 if val:
                     cvss_parts.append(f"{prefix}:{val}")
             text.append("CVSS Vector: ", style=FIELD_STYLE)
@@ -196,10 +190,13 @@ class CreateVulnerabilityReportRenderer(BaseToolRenderer):
             text.append("\n")
             text.append(technical_analysis)
 
-        if code_locations:
+        parsed_locations = (
+            parse_code_locations_xml(code_locations_xml) if code_locations_xml else None
+        )
+        if parsed_locations:
             text.append("\n\n")
             text.append("Code Locations", style=FIELD_STYLE)
-            for i, loc in enumerate(code_locations):
+            for i, loc in enumerate(parsed_locations):
                 text.append("\n\n")
                 text.append(f"  Location {i + 1}: ", style=DIM_STYLE)
                 text.append(loc.get("file", "unknown"), style=FILE_STYLE)

strix/interface/tool_components/scan_info_renderer.py

@@ -0,0 +1,68 @@
+from typing import Any, ClassVar
+
+from rich.text import Text
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
+
+
+@register_tool_renderer
+class ScanStartInfoRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "scan_start_info"
+    css_classes: ClassVar[list[str]] = ["tool-call", "scan-info-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        status = tool_data.get("status", "unknown")
+        targets = args.get("targets", [])
+
+        text = Text()
+        text.append("◈ ", style="#22c55e")
+        text.append("Starting penetration test")
+
+        if len(targets) == 1:
+            text.append(" on ")
+            text.append(cls._get_target_display(targets[0]))
+        elif len(targets) > 1:
+            text.append(f" on {len(targets)} targets")
+            for target_info in targets:
+                text.append("\n   • ")
+                text.append(cls._get_target_display(target_info))
+
+        css_classes = cls.get_css_classes(status)
+        return Static(text, classes=css_classes)
+
+    @classmethod
+    def _get_target_display(cls, target_info: dict[str, Any]) -> str:
+        original = target_info.get("original")
+        if original:
+            return str(original)
+        return "unknown target"
+
+
+@register_tool_renderer
+class SubagentStartInfoRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "subagent_start_info"
+    css_classes: ClassVar[list[str]] = ["tool-call", "subagent-info-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        status = tool_data.get("status", "unknown")
+
+        name = str(args.get("name", "Unknown Agent"))
+        task = str(args.get("task", ""))
+
+        text = Text()
+        text.append("◈ ", style="#a78bfa")
+        text.append("subagent ", style="dim")
+        text.append(name, style="bold #a78bfa")
+
+        if task:
+            text.append("\n  ")
+            text.append(task, style="dim")
+
+        css_classes = cls.get_css_classes(status)
+        return Static(text, classes=css_classes)

strix/interface/tool_components/terminal_renderer.py

@@ -0,0 +1,311 @@
+import re
+from functools import cache
+from typing import Any, ClassVar
+
+from pygments.lexers import get_lexer_by_name
+from pygments.styles import get_style_by_name
+from rich.text import Text
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
+
+
+MAX_OUTPUT_LINES = 50
+MAX_LINE_LENGTH = 200
+
+STRIP_PATTERNS = [
+    (
+        r"\n?\[Command still running after [\d.]+s - showing output so far\.?"
+        r"\s*(?:Use C-c to interrupt if needed\.)?\]"
+    ),
+    r"^\[Below is the output of the previous command\.\]\n?",
+    r"^No command is currently running\. Cannot send input\.$",
+    (
+        r"^A command is already running\. Use is_input=true to send input to it, "
+        r"or interrupt it first \(e\.g\., with C-c\)\.$"
+    ),
+]
+
+
+@cache
+def _get_style_colors() -> dict[Any, str]:
+    style = get_style_by_name("native")
+    return {token: f"#{style_def['color']}" for token, style_def in style if style_def["color"]}
+
+
+@register_tool_renderer
+class TerminalRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "terminal_execute"
+    css_classes: ClassVar[list[str]] = ["tool-call", "terminal-tool"]
+
+    CONTROL_SEQUENCES: ClassVar[set[str]] = {
+        "C-c",
+        "C-d",
+        "C-z",
+        "C-a",
+        "C-e",
+        "C-k",
+        "C-l",
+        "C-u",
+        "C-w",
+        "C-r",
+        "C-s",
+        "C-t",
+        "C-y",
+        "^c",
+        "^d",
+        "^z",
+        "^a",
+        "^e",
+        "^k",
+        "^l",
+        "^u",
+        "^w",
+        "^r",
+        "^s",
+        "^t",
+        "^y",
+    }
+    SPECIAL_KEYS: ClassVar[set[str]] = {
+        "Enter",
+        "Escape",
+        "Space",
+        "Tab",
+        "BTab",
+        "BSpace",
+        "DC",
+        "IC",
+        "Up",
+        "Down",
+        "Left",
+        "Right",
+        "Home",
+        "End",
+        "PageUp",
+        "PageDown",
+        "PgUp",
+        "PgDn",
+        "PPage",
+        "NPage",
+        "F1",
+        "F2",
+        "F3",
+        "F4",
+        "F5",
+        "F6",
+        "F7",
+        "F8",
+        "F9",
+        "F10",
+        "F11",
+        "F12",
+    }
+
+    @classmethod
+    def _get_token_color(cls, token_type: Any) -> str | None:
+        colors = _get_style_colors()
+        while token_type:
+            if token_type in colors:
+                return colors[token_type]
+            token_type = token_type.parent
+        return None
+
+    @classmethod
+    def _highlight_bash(cls, code: str) -> Text:
+        lexer = get_lexer_by_name("bash")
+        text = Text()
+
+        for token_type, token_value in lexer.get_tokens(code):
+            if not token_value:
+                continue
+            color = cls._get_token_color(token_type)
+            text.append(token_value, style=color)
+
+        return text
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        status = tool_data.get("status", "unknown")
+        result = tool_data.get("result")
+
+        command = args.get("command", "")
+        is_input = args.get("is_input", False)
+
+        content = cls._build_content(command, is_input, status, result)
+
+        css_classes = cls.get_css_classes(status)
+        return Static(content, classes=css_classes)
+
+    @classmethod
+    def _build_content(
+        cls, command: str, is_input: bool, status: str, result: dict[str, Any] | str | None
+    ) -> Text:
+        text = Text()
+        terminal_icon = ">_"
+
+        if not command.strip():
+            text.append(terminal_icon, style="dim")
+            text.append(" ")
+            text.append("getting logs...", style="dim")
+            if result:
+                cls._append_output(text, result, status, command)
+            return text
+
+        is_special = (
+            command in cls.CONTROL_SEQUENCES
+            or command in cls.SPECIAL_KEYS
+            or command.startswith(("M-", "S-", "C-S-", "C-M-", "S-M-"))
+        )
+
+        text.append(terminal_icon, style="dim")
+        text.append(" ")
+
+        if is_special:
+            text.append(command, style="#ef4444")
+        elif is_input:
+            text.append(">>>", style="#3b82f6")
+            text.append(" ")
+            text.append_text(cls._format_command(command))
+        else:
+            text.append("$", style="#22c55e")
+            text.append(" ")
+            text.append_text(cls._format_command(command))
+
+        if result:
+            cls._append_output(text, result, status, command)
+
+        return text
+
+    @classmethod
+    def _clean_output(cls, output: str, command: str = "") -> str:
+        cleaned = output
+
+        for pattern in STRIP_PATTERNS:
+            cleaned = re.sub(pattern, "", cleaned, flags=re.MULTILINE)
+
+        if cleaned.strip():
+            lines = cleaned.splitlines()
+            filtered_lines: list[str] = []
+            for line in lines:
+                if not filtered_lines and not line.strip():
+                    continue
+                if re.match(r"^\[STRIX_\d+\]\$\s*", line):
+                    continue
+                if command and line.strip() == command.strip():
+                    continue
+                if command and re.match(r"^[\$#>]\s*" + re.escape(command.strip()) + r"\s*$", line):
+                    continue
+                filtered_lines.append(line)
+
+            while filtered_lines and re.match(r"^\[STRIX_\d+\]\$\s*", filtered_lines[-1]):
+                filtered_lines.pop()
+
+            cleaned = "\n".join(filtered_lines)
+
+        return cleaned.strip()
+
+    @classmethod
+    def _append_output(
+        cls, text: Text, result: dict[str, Any] | str, tool_status: str, command: str = ""
+    ) -> None:
+        if isinstance(result, str):
+            if result.strip():
+                text.append("\n")
+                text.append_text(cls._format_output(result))
+            return
+
+        raw_output = result.get("content", "")
+        output = cls._clean_output(raw_output, command)
+        error = result.get("error")
+        exit_code = result.get("exit_code")
+        result_status = result.get("status", "")
+
+        if error and not cls._is_status_message(error):
+            text.append("\n")
+            text.append("  error: ", style="bold #ef4444")
+            text.append(cls._truncate_line(error), style="#ef4444")
+            return
+
+        if result_status == "running" or tool_status == "running":
+            if output and output.strip():
+                text.append("\n")
+                formatted_output = cls._format_output(output)
+                text.append_text(formatted_output)
+            return
+
+        if not output or not output.strip():
+            if exit_code is not None and exit_code != 0:
+                text.append("\n")
+                text.append(f"  exit {exit_code}", style="dim #ef4444")
+            return
+
+        text.append("\n")
+        formatted_output = cls._format_output(output)
+        text.append_text(formatted_output)
+
+        if exit_code is not None and exit_code != 0:
+            text.append("\n")
+            text.append(f"  exit {exit_code}", style="dim #ef4444")
+
+    @classmethod
+    def _is_status_message(cls, message: str) -> bool:
+        status_patterns = [
+            r"No command is currently running",
+            r"A command is already running",
+            r"Cannot send input",
+            r"Use is_input=true",
+            r"Use C-c to interrupt",
+            r"showing output so far",
+        ]
+        return any(re.search(pattern, message) for pattern in status_patterns)
+
+    @classmethod
+    def _format_output(cls, output: str) -> Text:
+        text = Text()
+        lines = output.splitlines()
+        total_lines = len(lines)
+
+        head_count = MAX_OUTPUT_LINES // 2
+        tail_count = MAX_OUTPUT_LINES - head_count - 1
+
+        if total_lines <= MAX_OUTPUT_LINES:
+            display_lines = lines
+            truncated = False
+            hidden_count = 0
+        else:
+            display_lines = lines[:head_count]
+            truncated = True
+            hidden_count = total_lines - head_count - tail_count
+
+        for i, line in enumerate(display_lines):
+            truncated_line = cls._truncate_line(line)
+            text.append("  ")
+            text.append(truncated_line, style="dim")
+            if i < len(display_lines) - 1 or truncated:
+                text.append("\n")
+
+        if truncated:
+            text.append(f"  ... {hidden_count} lines truncated ...", style="dim italic")
+            text.append("\n")
+            tail_lines = lines[-tail_count:]
+            for i, line in enumerate(tail_lines):
+                truncated_line = cls._truncate_line(line)
+                text.append("  ")
+                text.append(truncated_line, style="dim")
+                if i < len(tail_lines) - 1:
+                    text.append("\n")
+
+        return text
+
+    @classmethod
+    def _truncate_line(cls, line: str) -> str:
+        clean_line = re.sub(r"\x1b\[[0-9;]*m", "", line)
+        if len(clean_line) > MAX_LINE_LENGTH:
+            return line[: MAX_LINE_LENGTH - 3] + "..."
+        return line
+
+    @classmethod
+    def _format_command(cls, command: str) -> Text:
+        return cls._highlight_bash(command)

strix/interface/tool_components/user_message_renderer.py

@@ -1,7 +1,28 @@
+from typing import Any, ClassVar
+
 from rich.text import Text
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
 
 
-class UserMessageRenderer:
+@register_tool_renderer
+class UserMessageRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "user_message"
+    css_classes: ClassVar[list[str]] = ["chat-message", "user-message"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        content = tool_data.get("content", "")
+
+        if not content:
+            return Static(Text(), classes=" ".join(cls.css_classes))
+
+        styled_text = cls._format_user_message(content)
+
+        return Static(styled_text, classes=" ".join(cls.css_classes))
+
     @classmethod
     def render_simple(cls, content: str) -> Text:
         if not content:

strix/interface/tui/__init__.py

@@ -1,6 +0,0 @@
-"""Textual TUI interface."""
-
-from strix.interface.tui.app import StrixTUIApp, run_tui
-
-
-__all__ = ["StrixTUIApp", "run_tui"]

strix/interface/tui/history.py

@@ -1,60 +0,0 @@
-"""Historical SDK session loading for the TUI."""
-
-from __future__ import annotations
-
-import json
-import logging
-import sqlite3
-from datetime import UTC, datetime
-from typing import TYPE_CHECKING, Any
-
-from strix.core.paths import runtime_state_dir
-
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-
-logger = logging.getLogger(__name__)
-
-
-def load_session_history(run_dir: Path, agent_ids: Any) -> list[tuple[str, dict[str, Any], str]]:
-    agents_db = runtime_state_dir(run_dir) / "agents.db"
-    session_ids = [aid for aid in agent_ids if isinstance(aid, str)]
-    if not agents_db.exists() or not session_ids:
-        return []
-    session_id_set = set(session_ids)
-    try:
-        with sqlite3.connect(agents_db) as conn:
-            rows = conn.execute(
-                "select id, session_id, message_data, created_at from agent_messages order by id"
-            ).fetchall()
-    except sqlite3.Error:
-        logger.exception("Failed to hydrate TUI history from %s", agents_db)
-        return []
-
-    items: list[tuple[str, dict[str, Any], str]] = []
-    for row_id, agent_id, message_data, created_at in rows:
-        if agent_id not in session_id_set:
-            continue
-        try:
-            item = json.loads(message_data)
-        except (TypeError, json.JSONDecodeError):
-            logger.debug("Skipping unreadable SDK session item %s for %s", row_id, agent_id)
-            continue
-        if isinstance(item, dict):
-            items.append((str(agent_id), item, _sqlite_timestamp_to_iso(created_at)))
-    return items
-
-
-def _sqlite_timestamp_to_iso(value: Any) -> str:
-    if not isinstance(value, str) or not value.strip():
-        return datetime.now(UTC).isoformat()
-    text = value.strip()
-    try:
-        parsed = datetime.fromisoformat(text)
-    except ValueError:
-        return text
-    if parsed.tzinfo is None:
-        parsed = parsed.replace(tzinfo=UTC)
-    return parsed.astimezone(UTC).isoformat()

strix/interface/tui/live_view.py

@@ -1,356 +0,0 @@
-"""TUI-owned projection of SDK session history and stream events."""
-
-from __future__ import annotations
-
-import json
-from datetime import UTC, datetime
-from typing import TYPE_CHECKING, Any
-
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-from strix.core.paths import runtime_state_dir
-from strix.interface.tui.history import load_session_history
-
-
-class TuiLiveView:
-    def __init__(self) -> None:
-        self.agents: dict[str, dict[str, Any]] = {}
-        self.events: list[dict[str, Any]] = []
-        self._next_event_id = 1
-        self._open_assistant_event_by_agent: dict[str, dict[str, Any]] = {}
-        self._tool_event_by_call_id: dict[str, dict[str, Any]] = {}
-
-    def hydrate_from_run_dir(self, run_dir: Path) -> None:
-        state_dir = runtime_state_dir(run_dir)
-        agents_path = state_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),
-            )
-        self._hydrate_sdk_session_history(run_dir, statuses.keys())
-
-    def _hydrate_sdk_session_history(self, run_dir: Path, agent_ids: Any) -> None:
-        for agent_id, item, timestamp in load_session_history(run_dir, agent_ids):
-            self._ingest_session_history_item(
-                agent_id,
-                item,
-                timestamp=timestamp,
-            )
-
-    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 record_user_message(self, agent_id: str, content: str) -> None:
-        self._append_event(
-            agent_id,
-            "chat",
-            {
-                "role": "user",
-                "content": content,
-                "metadata": {"source": "tui_user"},
-            },
-        )
-
-    def ingest_sdk_event(self, agent_id: str, event: Any) -> None:
-        event_type = getattr(event, "type", "")
-        if event_type == "raw_response_event":
-            self._ingest_raw_response_event(agent_id, getattr(event, "data", None))
-            return
-        if event_type != "run_item_stream_event":
-            return
-
-        item = getattr(event, "item", None)
-        item_type = getattr(item, "type", "")
-        if item_type == "message_output_item":
-            self._record_assistant_message(agent_id, _sdk_message_text(item), final=True)
-        elif item_type == "tool_call_item":
-            self._record_tool_call(agent_id, item)
-        elif item_type == "tool_call_output_item":
-            self._record_tool_output(agent_id, item)
-
-    def events_for_agent(self, agent_id: str) -> list[dict[str, Any]]:
-        return [event for event in self.events if event.get("agent_id") == agent_id]
-
-    def has_events_for_agent(self, agent_id: str) -> bool:
-        return any(event.get("agent_id") == agent_id for event in self.events)
-
-    def _ingest_raw_response_event(self, agent_id: str, data: Any) -> None:
-        data_type = getattr(data, "type", "")
-        if data_type == "response.output_text.delta":
-            delta = getattr(data, "delta", "")
-            if delta:
-                self._record_assistant_message(agent_id, str(delta), final=False)
-
-    def _ingest_session_history_item(
-        self,
-        agent_id: str,
-        item: dict[str, Any],
-        *,
-        timestamp: str,
-    ) -> None:
-        item_type = item.get("type")
-        role = item.get("role")
-        if role in {"user", "assistant"} and (item_type in {None, "message"}):
-            content = _session_message_text(item)
-            if content:
-                self._append_event(
-                    agent_id,
-                    "chat",
-                    {
-                        "role": role,
-                        "content": content,
-                        "metadata": {"source": "sdk_session"},
-                    },
-                    timestamp=timestamp,
-                )
-            return
-
-        if item_type == "function_call":
-            self._record_tool_call_data(
-                agent_id,
-                {
-                    "call_id": str(item.get("call_id") or item.get("id") or ""),
-                    "tool_name": str(item.get("name") or "tool"),
-                    "args": _parse_json_object(item.get("arguments")),
-                },
-                timestamp=timestamp,
-            )
-            return
-
-        if item_type == "function_call_output":
-            self._record_tool_output_data(
-                agent_id,
-                {
-                    "call_id": str(item.get("call_id") or item.get("id") or ""),
-                    "tool_name": "tool",
-                    "output": item.get("output"),
-                },
-                timestamp=timestamp,
-            )
-
-    def _record_assistant_message(self, agent_id: str, content: str, *, final: bool) -> None:
-        if not content:
-            return
-        existing = self._open_assistant_event_by_agent.get(agent_id)
-        if existing is None:
-            event = self._append_event(
-                agent_id,
-                "chat",
-                {
-                    "role": "assistant",
-                    "content": content,
-                    "metadata": {"source": "sdk_stream", "streaming": not final},
-                },
-            )
-            if not final:
-                self._open_assistant_event_by_agent[agent_id] = event
-            return
-
-        data = existing["data"]
-        if final:
-            data["content"] = content
-            data["metadata"]["streaming"] = False
-            self._open_assistant_event_by_agent.pop(agent_id, None)
-        else:
-            data["content"] = f"{data.get('content', '')}{content}"
-        self._bump_event(existing)
-
-    def _record_tool_call(self, agent_id: str, item: Any) -> None:
-        self._record_tool_call_data(agent_id, _sdk_tool_call_data(item))
-
-    def _record_tool_call_data(
-        self,
-        agent_id: str,
-        call: dict[str, Any],
-        *,
-        timestamp: str | None = None,
-    ) -> None:
-        call_id = call["call_id"]
-        existing = self._tool_event_by_call_id.get(call_id)
-        tool_data = {
-            "tool_name": call["tool_name"],
-            "args": call["args"],
-            "status": "running",
-            "agent_id": agent_id,
-            "call_id": call_id,
-        }
-        if existing is None:
-            event = self._append_event(agent_id, "tool", tool_data, timestamp=timestamp)
-            self._tool_event_by_call_id[call_id] = event
-        else:
-            existing["data"].update(tool_data)
-            self._bump_event(existing, timestamp=timestamp)
-
-    def _record_tool_output(self, agent_id: str, item: Any) -> None:
-        self._record_tool_output_data(agent_id, _sdk_tool_output_data(item))
-
-    def _record_tool_output_data(
-        self,
-        agent_id: str,
-        output: dict[str, Any],
-        *,
-        timestamp: str | None = None,
-    ) -> None:
-        call_id = output["call_id"]
-        event = self._tool_event_by_call_id.get(call_id)
-        if event is None:
-            event = self._append_event(
-                agent_id,
-                "tool",
-                {
-                    "tool_name": output["tool_name"],
-                    "args": {},
-                    "status": "completed",
-                    "agent_id": agent_id,
-                    "call_id": call_id,
-                },
-                timestamp=timestamp,
-            )
-            self._tool_event_by_call_id[call_id] = event
-
-        result = _parse_json_value(output["output"])
-        event["data"]["result"] = result
-        event["data"]["status"] = _tool_status_from_result(result)
-        self._bump_event(event, timestamp=timestamp)
-
-    def _append_event(
-        self,
-        agent_id: str,
-        event_type: str,
-        data: dict[str, Any],
-        *,
-        timestamp: str | None = None,
-    ) -> dict[str, Any]:
-        event = {
-            "id": f"{event_type}_{self._next_event_id}",
-            "type": event_type,
-            "agent_id": agent_id,
-            "timestamp": timestamp or datetime.now(UTC).isoformat(),
-            "version": 0,
-            "data": data,
-        }
-        self._next_event_id += 1
-        self.events.append(event)
-        return event
-
-    @staticmethod
-    def _bump_event(event: dict[str, Any], *, timestamp: str | None = None) -> None:
-        event["version"] = int(event.get("version", 0)) + 1
-        event["timestamp"] = timestamp or datetime.now(UTC).isoformat()
-
-
-def _sdk_tool_call_data(item: Any) -> dict[str, Any]:
-    raw = getattr(item, "raw_item", None)
-    call_id = str(_raw_field(raw, "call_id") or _raw_field(raw, "id") or id(item))
-    tool_name = str(
-        _raw_field(raw, "name") or _raw_field(raw, "type") or getattr(item, "title", None) or "tool"
-    )
-    return {
-        "call_id": call_id,
-        "tool_name": tool_name,
-        "args": _parse_json_object(_raw_field(raw, "arguments")),
-    }
-
-
-def _sdk_tool_output_data(item: Any) -> dict[str, Any]:
-    raw = getattr(item, "raw_item", None)
-    call_id = str(_raw_field(raw, "call_id") or _raw_field(raw, "id") or id(item))
-    return {
-        "call_id": call_id,
-        "tool_name": str(_raw_field(raw, "name") or _raw_field(raw, "type") or "tool"),
-        "output": getattr(item, "output", _raw_field(raw, "output")),
-    }
-
-
-def _sdk_message_text(item: Any) -> str:
-    raw = getattr(item, "raw_item", None)
-    return _message_content_text(_raw_field(raw, "content", []))
-
-
-def _session_message_text(item: dict[str, Any]) -> str:
-    return _message_content_text(item.get("content", ""))
-
-
-def _message_content_text(content: Any) -> str:
-    parts: list[str] = []
-    content_items = content if isinstance(content, list) else [content]
-    for part in content_items:
-        if isinstance(part, str):
-            parts.append(part)
-            continue
-        text = _raw_field(part, "text")
-        if isinstance(text, str):
-            parts.append(text)
-    return "".join(parts)
-
-
-def _raw_field(raw: Any, key: str, default: Any = None) -> Any:
-    if isinstance(raw, dict):
-        return raw.get(key, default)
-    return getattr(raw, key, default)
-
-
-def _parse_json_object(value: Any) -> dict[str, Any]:
-    parsed = _parse_json_value(value)
-    return parsed if isinstance(parsed, dict) else {}
-
-
-def _parse_json_value(value: Any) -> Any:
-    if not isinstance(value, str):
-        return value
-    try:
-        return json.loads(value)
-    except json.JSONDecodeError:
-        return value
-
-
-def _tool_status_from_result(result: Any) -> str:
-    if isinstance(result, dict) and result.get("success") is False:
-        return "failed"
-    return "completed"

strix/interface/tui/messages.py

@@ -1,43 +0,0 @@
-"""Message delivery bridge from TUI input to SDK-backed agents."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Any
-
-
-logger = logging.getLogger(__name__)
-
-
-def send_user_message_to_agent(
-    *,
-    coordinator: Any,
-    loop: asyncio.AbstractEventLoop | None,
-    live_view: Any,
-    target_agent_id: str,
-    message: str,
-) -> bool:
-    if loop is None or loop.is_closed():
-        return False
-
-    live_view.record_user_message(target_agent_id, message)
-    future = asyncio.run_coroutine_threadsafe(
-        coordinator.send(
-            target_agent_id,
-            {"from": "user", "content": message, "type": "instruction"},
-        ),
-        loop,
-    )
-    future.add_done_callback(_log_delivery_failure)
-    return True
-
-
-def _log_delivery_failure(future: Any) -> None:
-    try:
-        delivered = bool(future.result())
-    except Exception:
-        logger.exception("TUI user message delivery failed")
-        return
-    if not delivered:
-        logger.warning("TUI user message was not persisted to the SDK session")

strix/interface/tui/renderers/__init__.py

@@ -1,30 +0,0 @@
-from . import (
-    agents_graph_renderer,
-    filesystem_renderer,
-    finish_renderer,
-    load_skill_renderer,
-    notes_renderer,
-    proxy_renderer,
-    reporting_renderer,
-    shell_renderer,
-    thinking_renderer,
-    todo_renderer,
-    web_search_renderer,
-)
-from .registry import render_tool_widget
-
-
-__all__ = [
-    "agents_graph_renderer",
-    "filesystem_renderer",
-    "finish_renderer",
-    "load_skill_renderer",
-    "notes_renderer",
-    "proxy_renderer",
-    "render_tool_widget",
-    "reporting_renderer",
-    "shell_renderer",
-    "thinking_renderer",
-    "todo_renderer",
-    "web_search_renderer",
-]

strix/interface/tui/renderers/base_renderer.py

@@ -1,30 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, ClassVar
-
-from textual.widgets import Static
-
-
-class BaseToolRenderer(ABC):
-    tool_name: ClassVar[str] = ""
-    css_classes: ClassVar[list[str]] = ["tool-call"]
-
-    @classmethod
-    @abstractmethod
-    def render(cls, tool_data: dict[str, Any]) -> Static:
-        pass
-
-    @classmethod
-    def status_icon(cls, status: str) -> tuple[str, str]:
-        icons = {
-            "running": ("● In progress...", "#f59e0b"),
-            "completed": ("✓ Done", "#22c55e"),
-            "failed": ("✗ Failed", "#dc2626"),
-            "error": ("✗ Error", "#dc2626"),
-        }
-        return icons.get(status, ("○ Unknown", "dim"))
-
-    @classmethod
-    def get_css_classes(cls, status: str) -> str:
-        base_classes = cls.css_classes.copy()
-        base_classes.append(f"status-{status}")
-        return " ".join(base_classes)

strix/interface/tui/renderers/filesystem_renderer.py

@@ -1,266 +0,0 @@
-from __future__ import annotations
-
-import json
-from functools import cache
-from typing import Any, ClassVar
-
-from pygments.lexers import get_lexer_by_name, get_lexer_for_filename
-from pygments.styles import get_style_by_name
-from pygments.util import ClassNotFound
-from rich.text import Text
-from textual.widgets import Static
-
-from .base_renderer import BaseToolRenderer
-from .registry import register_tool_renderer
-
-
-_ADD_FILE = "*** Add File: "
-_DELETE_FILE = "*** Delete File: "
-_UPDATE_FILE = "*** Update File: "
-_BEGIN_PATCH = "*** Begin Patch"
-_END_PATCH = "*** End Patch"
-
-_VIEW_IMAGE_ERROR_PREFIXES = (
-    "image path ",
-    "unable to read image",
-    "manifest path",
-    "exceeded the allowed size",
-)
-
-
-@cache
-def _get_style_colors() -> dict[Any, str]:
-    style = get_style_by_name("native")
-    return {token: f"#{style_def['color']}" for token, style_def in style if style_def["color"]}
-
-
-def _get_lexer_for_file(path: str) -> Any:
-    try:
-        return get_lexer_for_filename(path)
-    except ClassNotFound:
-        return get_lexer_by_name("text")
-
-
-def _get_token_color(token_type: Any) -> str | None:
-    colors = _get_style_colors()
-    while token_type:
-        if token_type in colors:
-            return colors[token_type]
-        token_type = token_type.parent
-    return None
-
-
-def _highlight_code(code: str, path: str) -> Text:
-    lexer = _get_lexer_for_file(path)
-    text = Text()
-    for token_type, token_value in lexer.get_tokens(code):
-        if not token_value:
-            continue
-        color = _get_token_color(token_type)
-        text.append(token_value, style=color)
-    return text
-
-
-def _extract_patch_text(args: dict[str, Any]) -> str:
-    """apply_patch input arrives as either {"patch": text} or raw text in
-    the "input" field, depending on whether the tool is wrapped as a
-    chat-completions FunctionTool or routed through as a CustomTool.
-    """
-    raw = args.get("patch")
-    if isinstance(raw, str):
-        return raw
-    if isinstance(raw, dict):
-        inner = raw.get("patch")
-        if isinstance(inner, str):
-            return inner
-    fallback = args.get("input") if isinstance(args, dict) else None
-    if isinstance(fallback, str):
-        return fallback
-    return ""
-
-
-def _parse_patch_operations(
-    patch_text: str,
-) -> list[tuple[str, str, list[str], list[str]]]:
-    """Return [(kind, path, old_lines, new_lines), ...] for each file op."""
-    ops: list[tuple[str, str, list[str], list[str]]] = []
-    current_kind: str | None = None
-    current_path: str | None = None
-    old_lines: list[str] = []
-    new_lines: list[str] = []
-
-    def flush() -> None:
-        nonlocal current_kind, current_path, old_lines, new_lines
-        if current_kind and current_path is not None:
-            ops.append((current_kind, current_path, old_lines, new_lines))
-        current_kind = None
-        current_path = None
-        old_lines = []
-        new_lines = []
-
-    for line in patch_text.splitlines():
-        if line in (_BEGIN_PATCH, _END_PATCH):
-            continue
-        if line.startswith(_ADD_FILE):
-            flush()
-            current_kind = "add"
-            current_path = line[len(_ADD_FILE) :].strip()
-        elif line.startswith(_UPDATE_FILE):
-            flush()
-            current_kind = "update"
-            current_path = line[len(_UPDATE_FILE) :].strip()
-        elif line.startswith(_DELETE_FILE):
-            flush()
-            current_kind = "delete"
-            current_path = line[len(_DELETE_FILE) :].strip()
-        elif current_kind == "update":
-            if line.startswith("@@"):
-                continue
-            if line.startswith("-") and not line.startswith("---"):
-                old_lines.append(line[1:])
-            elif line.startswith("+") and not line.startswith("+++"):
-                new_lines.append(line[1:])
-        elif current_kind == "add":
-            if line.startswith("+"):
-                new_lines.append(line[1:])
-            elif line.strip():
-                new_lines.append(line)
-    flush()
-    return ops
-
-
-_OP_LABEL = {
-    "add": "create",
-    "update": "edit",
-    "delete": "delete",
-}
-
-
-def _render_operation(text: Text, kind: str, path: str, old: list[str], new: list[str]) -> None:
-    label = _OP_LABEL.get(kind, "file")
-
-    text.append("◇ ", style="#10b981")
-    text.append(label, style="dim")
-
-    if path:
-        path_display = path[-60:] if len(path) > 60 else path
-        text.append(" ")
-        text.append(path_display, style="dim")
-
-    if kind == "update":
-        if old:
-            highlighted_old = _highlight_code("\n".join(old), path)
-            for line in highlighted_old.plain.split("\n"):
-                text.append("\n")
-                text.append("-", style="#ef4444")
-                text.append(" ")
-                text.append(line)
-        if new:
-            highlighted_new = _highlight_code("\n".join(new), path)
-            for line in highlighted_new.plain.split("\n"):
-                text.append("\n")
-                text.append("+", style="#22c55e")
-                text.append(" ")
-                text.append(line)
-    elif kind == "add" and new:
-        text.append("\n")
-        text.append_text(_highlight_code("\n".join(new), path))
-
-
-@register_tool_renderer
-class ApplyPatchRenderer(BaseToolRenderer):
-    tool_name: ClassVar[str] = "apply_patch"
-    css_classes: ClassVar[list[str]] = ["tool-call", "file-edit-tool"]
-
-    @classmethod
-    def render(cls, tool_data: dict[str, Any]) -> Static:
-        args = tool_data.get("args", {})
-        result = tool_data.get("result")
-        status = tool_data.get("status", "completed")
-
-        patch_text = _extract_patch_text(args)
-        ops = _parse_patch_operations(patch_text)
-
-        text = Text()
-
-        if not ops:
-            text.append("◇ ", style="#10b981")
-            text.append("patch", style="dim")
-            if isinstance(result, str) and result.strip():
-                text.append("\n  ")
-                text.append(result.strip(), style="dim")
-            elif not result:
-                text.append(" ")
-                text.append("Processing...", style="dim")
-            return Static(text, classes=cls.get_css_classes(status))
-
-        for i, (kind, path, old, new) in enumerate(ops):
-            if i > 0:
-                text.append("\n")
-            _render_operation(text, kind, path, old, new)
-
-        if status == "failed" and isinstance(result, str) and result.strip():
-            text.append("\n  ")
-            text.append(result.strip(), style="#ef4444")
-
-        return Static(text, classes=cls.get_css_classes(status))
-
-
-def _is_image_success(result: Any) -> bool:
-    if isinstance(result, dict) and result.get("type") == "image":
-        return True
-    if isinstance(result, str):
-        stripped = result.lstrip()
-        if stripped.startswith("data:image/"):
-            return True
-        try:
-            obj = json.loads(stripped)
-        except (TypeError, ValueError):
-            return False
-        return isinstance(obj, dict) and obj.get("type") == "image"
-    return False
-
-
-def _image_error_text(result: Any) -> str | None:
-    if not isinstance(result, str):
-        return None
-    stripped = result.strip()
-    if not stripped:
-        return None
-    lower = stripped.lower()
-    if lower.startswith(_VIEW_IMAGE_ERROR_PREFIXES) or "not a supported image" in lower:
-        return stripped
-    return None
-
-
-@register_tool_renderer
-class ViewImageRenderer(BaseToolRenderer):
-    tool_name: ClassVar[str] = "view_image"
-    css_classes: ClassVar[list[str]] = ["tool-call", "file-edit-tool"]
-
-    @classmethod
-    def render(cls, tool_data: dict[str, Any]) -> Static:
-        args = tool_data.get("args", {})
-        result = tool_data.get("result")
-        status = tool_data.get("status", "completed")
-
-        path = str(args.get("path", "")).strip()
-
-        text = Text()
-        text.append("◇ ", style="#10b981")
-        text.append("view image", style="dim")
-
-        if path:
-            path_display = path[-60:] if len(path) > 60 else path
-            text.append(" ")
-            text.append(path_display, style="dim")
-
-        err = _image_error_text(result)
-        if err is not None:
-            text.append("\n  ")
-            text.append(err, style="#ef4444")
-        elif _is_image_success(result):
-            text.append("  ")
-            text.append("✓", style="#22c55e")
-
-        return Static(text, classes=cls.get_css_classes(status))

strix/interface/tui/renderers/shell_renderer.py

@@ -1,266 +0,0 @@
-import re
-from functools import cache
-from typing import Any, ClassVar
-
-from pygments.lexers import get_lexer_by_name
-from pygments.styles import get_style_by_name
-from rich.text import Text
-from textual.widgets import Static
-
-from .base_renderer import BaseToolRenderer
-from .registry import register_tool_renderer
-
-
-MAX_OUTPUT_LINES = 50
-MAX_LINE_LENGTH = 200
-
-STRIP_PATTERNS = [
-    r"^Chunk ID: [0-9a-f]+\s*$",
-    r"^Wall time: [\d.]+ seconds\s*$",
-    r"^Process exited with code -?\d+\s*$",
-    r"^Process running with session ID \d+\s*$",
-    r"^Original token count: \d+\s*$",
-]
-
-_EXIT_RE = re.compile(r"Process exited with code (-?\d+)")
-_SESSION_RE = re.compile(r"Process running with session ID (\d+)")
-_OUTPUT_HEADER = "\nOutput:\n"
-
-_CONTROL_BYTES_TO_DROP = dict.fromkeys(
-    [b for b in range(0x20) if b not in (0x09, 0x0A)] + [0x7F],
-    None,
-)
-
-
-@cache
-def _get_style_colors() -> dict[Any, str]:
-    style = get_style_by_name("native")
-    return {token: f"#{style_def['color']}" for token, style_def in style if style_def["color"]}
-
-
-def _parse_sdk_shell_result(result: Any) -> dict[str, Any]:
-    """Translate the SDK's terminal-output string into the dict shape the
-    renderer's `_append_output` helper expects.
-
-    The SDK returns a header-prefixed string ending with `Output:\\n<actual>`.
-    We extract `content`, `exit_code`, and `session_id`; anything else (or a
-    non-string result) flows through unchanged so renderers can handle errors.
-    """
-    if isinstance(result, dict):
-        return result
-    if not isinstance(result, str):
-        return {"content": "" if result is None else str(result)}
-
-    exit_match = _EXIT_RE.search(result)
-    session_match = _SESSION_RE.search(result)
-    idx = result.find(_OUTPUT_HEADER)
-    content = result[idx + len(_OUTPUT_HEADER) :] if idx >= 0 else result
-
-    parsed: dict[str, Any] = {"content": content}
-    if exit_match:
-        parsed["exit_code"] = int(exit_match.group(1))
-    if session_match:
-        parsed["session_id"] = int(session_match.group(1))
-    return parsed
-
-
-def _truncate_line(line: str) -> str:
-    if len(line) > MAX_LINE_LENGTH:
-        return line[: MAX_LINE_LENGTH - 3] + "..."
-    return line
-
-
-def _clean_output(output: str) -> str:
-    cleaned: str = Text.from_ansi(output).plain.translate(_CONTROL_BYTES_TO_DROP)
-    for pattern in STRIP_PATTERNS:
-        cleaned = re.sub(pattern, "", cleaned, flags=re.MULTILINE)
-
-    if cleaned.strip():
-        lines = cleaned.splitlines()
-        filtered_lines: list[str] = []
-        for line in lines:
-            if not filtered_lines and not line.strip():
-                continue
-            if line.strip() == "Output:":
-                continue
-            filtered_lines.append(line)
-        while filtered_lines and not filtered_lines[-1].strip():
-            filtered_lines.pop()
-        cleaned = "\n".join(filtered_lines)
-
-    return cleaned.strip()
-
-
-def _format_output(output: str) -> Text:
-    text = Text()
-    lines = output.splitlines()
-    total_lines = len(lines)
-
-    head_count = MAX_OUTPUT_LINES // 2
-    tail_count = MAX_OUTPUT_LINES - head_count - 1
-
-    if total_lines <= MAX_OUTPUT_LINES:
-        display_lines = lines
-        truncated = False
-        hidden_count = 0
-    else:
-        display_lines = lines[:head_count]
-        truncated = True
-        hidden_count = total_lines - head_count - tail_count
-
-    for i, line in enumerate(display_lines):
-        text.append("  ")
-        text.append(_truncate_line(line), style="dim")
-        if i < len(display_lines) - 1 or truncated:
-            text.append("\n")
-
-    if truncated:
-        text.append(f"  ... {hidden_count} lines truncated ...", style="dim italic")
-        text.append("\n")
-        tail_lines = lines[-tail_count:]
-        for i, line in enumerate(tail_lines):
-            text.append("  ")
-            text.append(_truncate_line(line), style="dim")
-            if i < len(tail_lines) - 1:
-                text.append("\n")
-
-    return text
-
-
-def _get_token_color(token_type: Any) -> str | None:
-    colors = _get_style_colors()
-    while token_type:
-        if token_type in colors:
-            return colors[token_type]
-        token_type = token_type.parent
-    return None
-
-
-def _highlight_bash(code: str) -> Text:
-    lexer = get_lexer_by_name("bash")
-    text = Text()
-    for token_type, token_value in lexer.get_tokens(code):
-        if not token_value:
-            continue
-        color = _get_token_color(token_type)
-        text.append(token_value, style=color)
-    return text
-
-
-def _append_output(text: Text, parsed: dict[str, Any], tool_status: str) -> None:
-    raw_output = parsed.get("content", "") or ""
-    output = _clean_output(raw_output) if isinstance(raw_output, str) else ""
-    exit_code = parsed.get("exit_code")
-
-    if tool_status == "running":
-        if output:
-            text.append("\n")
-            text.append_text(_format_output(output))
-        return
-
-    if not output:
-        if exit_code is not None and exit_code != 0:
-            text.append("\n")
-            text.append(f"  exit {exit_code}", style="dim #ef4444")
-        return
-
-    text.append("\n")
-    text.append_text(_format_output(output))
-
-    if exit_code is not None and exit_code != 0:
-        text.append("\n")
-        text.append(f"  exit {exit_code}", style="dim #ef4444")
-
-
-def _build_terminal_content(
-    *,
-    prompt: str,
-    prompt_style: str,
-    command: str,
-    parsed_result: dict[str, Any] | None,
-    tool_status: str,
-    meta: str | None = None,
-) -> Text:
-    text = Text()
-    text.append(">_", style="dim")
-    text.append(" ")
-
-    if not command.strip():
-        text.append("getting logs...", style="dim")
-    else:
-        text.append(prompt, style=prompt_style)
-        text.append(" ")
-        text.append_text(_highlight_bash(command))
-
-    if meta:
-        text.append(f"  {meta}", style="dim")
-
-    if parsed_result is not None:
-        _append_output(text, parsed_result, tool_status)
-
-    return text
-
-
-@register_tool_renderer
-class ExecCommandRenderer(BaseToolRenderer):
-    tool_name: ClassVar[str] = "exec_command"
-    css_classes: ClassVar[list[str]] = ["tool-call", "terminal-tool"]
-
-    @classmethod
-    def render(cls, tool_data: dict[str, Any]) -> Static:
-        args = tool_data.get("args", {})
-        status = tool_data.get("status", "unknown")
-        result = tool_data.get("result")
-
-        cmd = str(args.get("cmd", ""))
-        workdir = args.get("workdir")
-        tty = bool(args.get("tty"))
-
-        meta_parts: list[str] = []
-        if workdir:
-            meta_parts.append(f"cwd:{workdir}")
-        if tty:
-            meta_parts.append("tty")
-        meta = ", ".join(meta_parts) if meta_parts else None
-
-        parsed = _parse_sdk_shell_result(result) if result is not None else None
-
-        content = _build_terminal_content(
-            prompt="$",
-            prompt_style="#22c55e",
-            command=cmd,
-            parsed_result=parsed,
-            tool_status=status,
-            meta=meta,
-        )
-
-        return Static(content, classes=cls.get_css_classes(status))
-
-
-@register_tool_renderer
-class WriteStdinRenderer(BaseToolRenderer):
-    tool_name: ClassVar[str] = "write_stdin"
-    css_classes: ClassVar[list[str]] = ["tool-call", "terminal-tool"]
-
-    @classmethod
-    def render(cls, tool_data: dict[str, Any]) -> Static:
-        args = tool_data.get("args", {})
-        status = tool_data.get("status", "unknown")
-        result = tool_data.get("result")
-
-        chars = str(args.get("chars", ""))
-        session_id = args.get("session_id")
-        meta = f"session #{session_id}" if session_id is not None else None
-
-        parsed = _parse_sdk_shell_result(result) if result is not None else None
-
-        content = _build_terminal_content(
-            prompt=">>>",
-            prompt_style="#3b82f6",
-            command=chars,
-            parsed_result=parsed,
-            tool_status=status,
-            meta=meta,
-        )
-
-        return Static(content, classes=cls.get_css_classes(status))

strix/llm/__init__.py

@@ -0,0 +1,19 @@
+import logging
+import warnings
+
+import litellm
+
+from .config import LLMConfig
+from .llm import LLM, LLMRequestFailedError
+
+
+__all__ = [
+    "LLM",
+    "LLMConfig",
+    "LLMRequestFailedError",
+]
+
+litellm._logging._disable_debugging()
+logging.getLogger("asyncio").setLevel(logging.CRITICAL)
+logging.getLogger("asyncio").propagate = False
+warnings.filterwarnings("ignore", category=RuntimeWarning, module="asyncio")

strix/llm/config.py

@@ -0,0 +1,39 @@
+from typing import Any
+
+from strix.config import Config
+from strix.config.config import resolve_llm_config
+from strix.llm.utils import resolve_strix_model
+
+
+class LLMConfig:
+    def __init__(
+        self,
+        model_name: str | None = None,
+        enable_prompt_caching: bool = True,
+        skills: list[str] | None = None,
+        timeout: int | None = None,
+        scan_mode: str = "deep",
+        interactive: bool = False,
+        reasoning_effort: str | None = None,
+        system_prompt_context: dict[str, Any] | None = None,
+    ):
+        resolved_model, self.api_key, self.api_base = resolve_llm_config()
+        self.model_name = model_name or resolved_model
+
+        if not self.model_name:
+            raise ValueError("STRIX_LLM environment variable must be set and not empty")
+
+        api_model, canonical = resolve_strix_model(self.model_name)
+        self.litellm_model: str = api_model or self.model_name
+        self.canonical_model: str = canonical or self.model_name
+
+        self.enable_prompt_caching = enable_prompt_caching
+        self.skills = skills or []
+
+        self.timeout = timeout or int(Config.get("llm_timeout") or "300")
+
+        self.scan_mode = scan_mode if scan_mode in ["quick", "standard", "deep"] else "deep"
+
+        self.interactive = interactive
+        self.reasoning_effort = reasoning_effort
+        self.system_prompt_context = system_prompt_context or {}

strix/llm/dedupe.py

@@ -0,0 +1,213 @@
+import json
+import logging
+import re
+from typing import Any
+
+import litellm
+
+from strix.config.config import resolve_llm_config
+from strix.llm.utils import resolve_strix_model
+
+
+logger = logging.getLogger(__name__)
+
+DEDUPE_SYSTEM_PROMPT = """You are an expert vulnerability report deduplication judge.
+Your task is to determine if a candidate vulnerability report describes the SAME vulnerability
+as any existing report.
+
+CRITICAL DEDUPLICATION RULES:
+
+1. SAME VULNERABILITY means:
+   - Same root cause (e.g., "missing input validation" not just "SQL injection")
+   - Same affected component/endpoint/file (exact match or clear overlap)
+   - Same exploitation method or attack vector
+   - Would be fixed by the same code change/patch
+
+2. NOT DUPLICATES if:
+   - Different endpoints even with same vulnerability type (e.g., SQLi in /login vs /search)
+   - Different parameters in same endpoint (e.g., XSS in 'name' vs 'comment' field)
+   - Different root causes (e.g., stored XSS vs reflected XSS in same field)
+   - Different severity levels due to different impact
+   - One is authenticated, other is unauthenticated
+
+3. ARE DUPLICATES even if:
+   - Titles are worded differently
+   - Descriptions have different level of detail
+   - PoC uses different payloads but exploits same issue
+   - One report is more thorough than another
+   - Minor variations in technical analysis
+
+COMPARISON GUIDELINES:
+- Focus on the technical root cause, not surface-level similarities
+- Same vulnerability type (SQLi, XSS) doesn't mean duplicate - location matters
+- Consider the fix: would fixing one also fix the other?
+- When uncertain, lean towards NOT duplicate
+
+FIELDS TO ANALYZE:
+- title, description: General vulnerability info
+- target, endpoint, method: Exact location of vulnerability
+- technical_analysis: Root cause details
+- poc_description: How it's exploited
+- impact: What damage it can cause
+
+YOU MUST RESPOND WITH EXACTLY THIS XML FORMAT AND NOTHING ELSE:
+
+<dedupe_result>
+<is_duplicate>true</is_duplicate>
+<duplicate_id>vuln-0001</duplicate_id>
+<confidence>0.95</confidence>
+<reason>Both reports describe SQL injection in /api/login via the username parameter</reason>
+</dedupe_result>
+
+OR if not a duplicate:
+
+<dedupe_result>
+<is_duplicate>false</is_duplicate>
+<duplicate_id></duplicate_id>
+<confidence>0.90</confidence>
+<reason>Different endpoints: candidate is /api/search, existing is /api/login</reason>
+</dedupe_result>
+
+RULES:
+- is_duplicate MUST be exactly "true" or "false" (lowercase)
+- duplicate_id MUST be the exact ID from existing reports or empty if not duplicate
+- confidence MUST be a decimal (your confidence level in the decision)
+- reason MUST be a specific explanation mentioning endpoint/parameter/root cause
+- DO NOT include any text outside the <dedupe_result> tags"""
+
+
+def _prepare_report_for_comparison(report: dict[str, Any]) -> dict[str, Any]:
+    relevant_fields = [
+        "id",
+        "title",
+        "description",
+        "impact",
+        "target",
+        "technical_analysis",
+        "poc_description",
+        "endpoint",
+        "method",
+    ]
+
+    cleaned = {}
+    for field in relevant_fields:
+        if report.get(field):
+            value = report[field]
+            if isinstance(value, str) and len(value) > 8000:
+                value = value[:8000] + "...[truncated]"
+            cleaned[field] = value
+
+    return cleaned
+
+
+def _extract_xml_field(content: str, field: str) -> str:
+    pattern = rf"<{field}>(.*?)</{field}>"
+    match = re.search(pattern, content, re.DOTALL | re.IGNORECASE)
+    if match:
+        return match.group(1).strip()
+    return ""
+
+
+def _parse_dedupe_response(content: str) -> dict[str, Any]:
+    result_match = re.search(
+        r"<dedupe_result>(.*?)</dedupe_result>", content, re.DOTALL | re.IGNORECASE
+    )
+
+    if not result_match:
+        logger.warning(f"No <dedupe_result> block found in response: {content[:500]}")
+        raise ValueError("No <dedupe_result> block found in response")
+
+    result_content = result_match.group(1)
+
+    is_duplicate_str = _extract_xml_field(result_content, "is_duplicate")
+    duplicate_id = _extract_xml_field(result_content, "duplicate_id")
+    confidence_str = _extract_xml_field(result_content, "confidence")
+    reason = _extract_xml_field(result_content, "reason")
+
+    is_duplicate = is_duplicate_str.lower() == "true"
+
+    try:
+        confidence = float(confidence_str) if confidence_str else 0.0
+    except ValueError:
+        confidence = 0.0
+
+    return {
+        "is_duplicate": is_duplicate,
+        "duplicate_id": duplicate_id[:64] if duplicate_id else "",
+        "confidence": confidence,
+        "reason": reason[:500] if reason else "",
+    }
+
+
+def check_duplicate(
+    candidate: dict[str, Any], existing_reports: list[dict[str, Any]]
+) -> dict[str, Any]:
+    if not existing_reports:
+        return {
+            "is_duplicate": False,
+            "duplicate_id": "",
+            "confidence": 1.0,
+            "reason": "No existing reports to compare against",
+        }
+
+    try:
+        candidate_cleaned = _prepare_report_for_comparison(candidate)
+        existing_cleaned = [_prepare_report_for_comparison(r) for r in existing_reports]
+
+        comparison_data = {"candidate": candidate_cleaned, "existing_reports": existing_cleaned}
+
+        model_name, api_key, api_base = resolve_llm_config()
+        litellm_model, _ = resolve_strix_model(model_name)
+        litellm_model = litellm_model or model_name
+
+        messages = [
+            {"role": "system", "content": DEDUPE_SYSTEM_PROMPT},
+            {
+                "role": "user",
+                "content": (
+                    f"Compare this candidate vulnerability against existing reports:\n\n"
+                    f"{json.dumps(comparison_data, indent=2)}\n\n"
+                    f"Respond with ONLY the <dedupe_result> XML block."
+                ),
+            },
+        ]
+
+        completion_kwargs: dict[str, Any] = {
+            "model": litellm_model,
+            "messages": messages,
+            "timeout": 120,
+        }
+        if api_key:
+            completion_kwargs["api_key"] = api_key
+        if api_base:
+            completion_kwargs["api_base"] = api_base
+
+        response = litellm.completion(**completion_kwargs)
+
+        content = response.choices[0].message.content
+        if not content:
+            return {
+                "is_duplicate": False,
+                "duplicate_id": "",
+                "confidence": 0.0,
+                "reason": "Empty response from LLM",
+            }
+
+        result = _parse_dedupe_response(content)
+
+        logger.info(
+            f"Deduplication check: is_duplicate={result['is_duplicate']}, "
+            f"confidence={result['confidence']}, reason={result['reason'][:100]}"
+        )
+
+    except Exception as e:
+        logger.exception("Error during vulnerability deduplication check")
+        return {
+            "is_duplicate": False,
+            "duplicate_id": "",
+            "confidence": 0.0,
+            "reason": f"Deduplication check failed: {e}",
+            "error": str(e),
+        }
+    else:
+        return result

strix/llm/llm.py

@@ -0,0 +1,375 @@
+import asyncio
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from typing import Any
+
+import litellm
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+from litellm import acompletion, completion_cost, stream_chunk_builder, supports_reasoning
+from litellm.utils import supports_prompt_caching, supports_vision
+
+from strix.config import Config
+from strix.llm.config import LLMConfig
+from strix.llm.memory_compressor import MemoryCompressor
+from strix.llm.utils import (
+    _truncate_to_first_function,
+    fix_incomplete_tool_call,
+    normalize_tool_format,
+    parse_tool_invocations,
+)
+from strix.skills import load_skills
+from strix.tools import get_tools_prompt
+from strix.utils.resource_paths import get_strix_resource_path
+
+
+litellm.drop_params = True
+litellm.modify_params = True
+
+
+class LLMRequestFailedError(Exception):
+    def __init__(self, message: str, details: str | None = None):
+        super().__init__(message)
+        self.message = message
+        self.details = details
+
+
+@dataclass
+class LLMResponse:
+    content: str
+    tool_invocations: list[dict[str, Any]] | None = None
+    thinking_blocks: list[dict[str, Any]] | None = None
+
+
+@dataclass
+class RequestStats:
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cached_tokens: int = 0
+    cost: float = 0.0
+    requests: int = 0
+
+    def to_dict(self) -> dict[str, int | float]:
+        return {
+            "input_tokens": self.input_tokens,
+            "output_tokens": self.output_tokens,
+            "cached_tokens": self.cached_tokens,
+            "cost": round(self.cost, 4),
+            "requests": self.requests,
+        }
+
+
+class LLM:
+    def __init__(self, config: LLMConfig, agent_name: str | None = None):
+        self.config = config
+        self.agent_name = agent_name
+        self.agent_id: str | None = None
+        self._active_skills: list[str] = list(config.skills or [])
+        self._system_prompt_context: dict[str, Any] = dict(
+            getattr(config, "system_prompt_context", {}) or {}
+        )
+        self._total_stats = RequestStats()
+        self.memory_compressor = MemoryCompressor(model_name=config.litellm_model)
+        self.system_prompt = self._load_system_prompt(agent_name)
+
+        reasoning = Config.get("strix_reasoning_effort")
+        if reasoning:
+            self._reasoning_effort = reasoning
+        elif config.reasoning_effort:
+            self._reasoning_effort = config.reasoning_effort
+        elif config.scan_mode == "quick":
+            self._reasoning_effort = "medium"
+        else:
+            self._reasoning_effort = "high"
+
+    def _load_system_prompt(self, agent_name: str | None) -> str:
+        if not agent_name:
+            return ""
+
+        try:
+            prompt_dir = get_strix_resource_path("agents", agent_name)
+            skills_dir = get_strix_resource_path("skills")
+            env = Environment(
+                loader=FileSystemLoader([prompt_dir, skills_dir]),
+                autoescape=select_autoescape(enabled_extensions=(), default_for_string=False),
+            )
+
+            skills_to_load = self._get_skills_to_load()
+            skill_content = load_skills(skills_to_load)
+            env.globals["get_skill"] = lambda name: skill_content.get(name, "")
+
+            result = env.get_template("system_prompt.jinja").render(
+                get_tools_prompt=get_tools_prompt,
+                loaded_skill_names=list(skill_content.keys()),
+                interactive=self.config.interactive,
+                system_prompt_context=self._system_prompt_context,
+                **skill_content,
+            )
+            return str(result)
+        except Exception:  # noqa: BLE001
+            return ""
+
+    def _get_skills_to_load(self) -> list[str]:
+        ordered_skills = [*self._active_skills]
+        ordered_skills.append(f"scan_modes/{self.config.scan_mode}")
+
+        deduped: list[str] = []
+        seen: set[str] = set()
+        for skill_name in ordered_skills:
+            if skill_name not in seen:
+                deduped.append(skill_name)
+                seen.add(skill_name)
+
+        return deduped
+
+    def add_skills(self, skill_names: list[str]) -> list[str]:
+        added: list[str] = []
+        for skill_name in skill_names:
+            if not skill_name or skill_name in self._active_skills:
+                continue
+            self._active_skills.append(skill_name)
+            added.append(skill_name)
+
+        if not added:
+            return []
+
+        updated_prompt = self._load_system_prompt(self.agent_name)
+        if updated_prompt:
+            self.system_prompt = updated_prompt
+
+        return added
+
+    def set_agent_identity(self, agent_name: str | None, agent_id: str | None) -> None:
+        if agent_name:
+            self.agent_name = agent_name
+        if agent_id:
+            self.agent_id = agent_id
+
+    def set_system_prompt_context(self, context: dict[str, Any] | None) -> None:
+        self._system_prompt_context = dict(context or {})
+        updated_prompt = self._load_system_prompt(self.agent_name)
+        if updated_prompt:
+            self.system_prompt = updated_prompt
+
+    async def generate(
+        self, conversation_history: list[dict[str, Any]]
+    ) -> AsyncIterator[LLMResponse]:
+        messages = self._prepare_messages(conversation_history)
+        max_retries = int(Config.get("strix_llm_max_retries") or "5")
+
+        for attempt in range(max_retries + 1):
+            try:
+                async for response in self._stream(messages):
+                    yield response
+                return  # noqa: TRY300
+            except Exception as e:  # noqa: BLE001
+                if attempt >= max_retries or not self._should_retry(e):
+                    self._raise_error(e)
+                wait = min(90, 2 * (2**attempt))
+                await asyncio.sleep(wait)
+
+    async def _stream(self, messages: list[dict[str, Any]]) -> AsyncIterator[LLMResponse]:
+        accumulated = ""
+        chunks: list[Any] = []
+        done_streaming = 0
+
+        self._total_stats.requests += 1
+        response = await acompletion(**self._build_completion_args(messages), stream=True)
+
+        async for chunk in response:
+            chunks.append(chunk)
+            if done_streaming:
+                done_streaming += 1
+                if getattr(chunk, "usage", None) or done_streaming > 5:
+                    break
+                continue
+            delta = self._get_chunk_content(chunk)
+            if delta:
+                accumulated += delta
+                if "</function>" in accumulated or "</invoke>" in accumulated:
+                    end_tag = "</function>" if "</function>" in accumulated else "</invoke>"
+                    pos = accumulated.find(end_tag)
+                    accumulated = accumulated[: pos + len(end_tag)]
+                    yield LLMResponse(content=accumulated)
+                    done_streaming = 1
+                    continue
+                yield LLMResponse(content=accumulated)
+
+        if chunks:
+            self._update_usage_stats(stream_chunk_builder(chunks))
+
+        accumulated = normalize_tool_format(accumulated)
+        accumulated = fix_incomplete_tool_call(_truncate_to_first_function(accumulated))
+        yield LLMResponse(
+            content=accumulated,
+            tool_invocations=parse_tool_invocations(accumulated),
+            thinking_blocks=self._extract_thinking(chunks),
+        )
+
+    def _prepare_messages(self, conversation_history: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        messages = [{"role": "system", "content": self.system_prompt}]
+
+        if self.agent_name:
+            messages.append(
+                {
+                    "role": "user",
+                    "content": (
+                        f"\n\n<agent_identity>\n"
+                        f"<meta>Internal metadata: do not echo or reference.</meta>\n"
+                        f"<agent_name>{self.agent_name}</agent_name>\n"
+                        f"<agent_id>{self.agent_id}</agent_id>\n"
+                        f"</agent_identity>\n\n"
+                    ),
+                }
+            )
+
+        compressed = list(self.memory_compressor.compress_history(conversation_history))
+        conversation_history.clear()
+        conversation_history.extend(compressed)
+        messages.extend(compressed)
+
+        if messages[-1].get("role") == "assistant" and not self.config.interactive:
+            messages.append({"role": "user", "content": "<meta>Continue the task.</meta>"})
+
+        if self._is_anthropic() and self.config.enable_prompt_caching:
+            messages = self._add_cache_control(messages)
+
+        return messages
+
+    def _build_completion_args(self, messages: list[dict[str, Any]]) -> dict[str, Any]:
+        if not self._supports_vision():
+            messages = self._strip_images(messages)
+
+        args: dict[str, Any] = {
+            "model": self.config.litellm_model,
+            "messages": messages,
+            "timeout": self.config.timeout,
+            "stream_options": {"include_usage": True},
+        }
+
+        if self.config.api_key:
+            args["api_key"] = self.config.api_key
+        if self.config.api_base:
+            args["api_base"] = self.config.api_base
+        if self._supports_reasoning():
+            args["reasoning_effort"] = self._reasoning_effort
+
+        return args
+
+    def _get_chunk_content(self, chunk: Any) -> str:
+        if chunk.choices and hasattr(chunk.choices[0], "delta"):
+            return getattr(chunk.choices[0].delta, "content", "") or ""
+        return ""
+
+    def _extract_thinking(self, chunks: list[Any]) -> list[dict[str, Any]] | None:
+        if not chunks or not self._supports_reasoning():
+            return None
+        try:
+            resp = stream_chunk_builder(chunks)
+            if resp.choices and hasattr(resp.choices[0].message, "thinking_blocks"):
+                blocks: list[dict[str, Any]] = resp.choices[0].message.thinking_blocks
+                return blocks
+        except Exception:  # noqa: BLE001, S110  # nosec B110
+            pass
+        return None
+
+    def _update_usage_stats(self, response: Any) -> None:
+        try:
+            if hasattr(response, "usage") and response.usage:
+                input_tokens = getattr(response.usage, "prompt_tokens", 0) or 0
+                output_tokens = getattr(response.usage, "completion_tokens", 0) or 0
+
+                cached_tokens = 0
+                if hasattr(response.usage, "prompt_tokens_details"):
+                    prompt_details = response.usage.prompt_tokens_details
+                    if hasattr(prompt_details, "cached_tokens"):
+                        cached_tokens = prompt_details.cached_tokens or 0
+
+                cost = self._extract_cost(response)
+            else:
+                input_tokens = 0
+                output_tokens = 0
+                cached_tokens = 0
+                cost = 0.0
+
+            self._total_stats.input_tokens += input_tokens
+            self._total_stats.output_tokens += output_tokens
+            self._total_stats.cached_tokens += cached_tokens
+            self._total_stats.cost += cost
+
+        except Exception:  # noqa: BLE001, S110  # nosec B110
+            pass
+
+    def _extract_cost(self, response: Any) -> float:
+        if hasattr(response, "usage") and response.usage:
+            direct_cost = getattr(response.usage, "cost", None)
+            if direct_cost is not None:
+                return float(direct_cost)
+        try:
+            if hasattr(response, "_hidden_params"):
+                response._hidden_params.pop("custom_llm_provider", None)
+            return completion_cost(response, model=self.config.canonical_model) or 0.0
+        except Exception:  # noqa: BLE001
+            return 0.0
+
+    def _should_retry(self, e: Exception) -> bool:
+        code = getattr(e, "status_code", None) or getattr(
+            getattr(e, "response", None), "status_code", None
+        )
+        return code is None or litellm._should_retry(code)
+
+    def _raise_error(self, e: Exception) -> None:
+        from strix.telemetry import posthog
+
+        posthog.error("llm_error", type(e).__name__)
+        raise LLMRequestFailedError(f"LLM request failed: {type(e).__name__}", str(e)) from e
+
+    def _is_anthropic(self) -> bool:
+        if not self.config.model_name:
+            return False
+        return any(p in self.config.model_name.lower() for p in ["anthropic/", "claude"])
+
+    def _supports_vision(self) -> bool:
+        try:
+            return bool(supports_vision(model=self.config.canonical_model))
+        except Exception:  # noqa: BLE001
+            return False
+
+    def _supports_reasoning(self) -> bool:
+        try:
+            return bool(supports_reasoning(model=self.config.canonical_model))
+        except Exception:  # noqa: BLE001
+            return False
+
+    def _strip_images(self, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        result = []
+        for msg in messages:
+            content = msg.get("content")
+            if isinstance(content, list):
+                text_parts = []
+                for item in content:
+                    if isinstance(item, dict) and item.get("type") == "text":
+                        text_parts.append(item.get("text", ""))
+                    elif isinstance(item, dict) and item.get("type") == "image_url":
+                        text_parts.append("[Image removed - model doesn't support vision]")
+                result.append({**msg, "content": "\n".join(text_parts)})
+            else:
+                result.append(msg)
+        return result
+
+    def _add_cache_control(self, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        if not messages or not supports_prompt_caching(self.config.canonical_model):
+            return messages
+
+        result = list(messages)
+
+        if result[0].get("role") == "system":
+            content = result[0]["content"]
+            result[0] = {
+                **result[0],
+                "content": [
+                    {"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}
+                ]
+                if isinstance(content, str)
+                else content,
+            }
+        return result

strix/llm/memory_compressor.py

@@ -0,0 +1,219 @@
+import logging
+from typing import Any
+
+import litellm
+
+from strix.config.config import Config, resolve_llm_config
+
+
+logger = logging.getLogger(__name__)
+
+
+MAX_TOTAL_TOKENS = 100_000
+MIN_RECENT_MESSAGES = 15
+
+SUMMARY_PROMPT_TEMPLATE = """You are an agent performing context
+condensation for a security agent. Your job is to compress scan data while preserving
+ALL operationally critical information for continuing the security assessment.
+
+CRITICAL ELEMENTS TO PRESERVE:
+- Discovered vulnerabilities and potential attack vectors
+- Scan results and tool outputs (compressed but maintaining key findings)
+- Access credentials, tokens, or authentication details found
+- System architecture insights and potential weak points
+- Progress made in the assessment
+- Failed attempts and dead ends (to avoid duplication)
+- Any decisions made about the testing approach
+
+COMPRESSION GUIDELINES:
+- Preserve exact technical details (URLs, paths, parameters, payloads)
+- Summarize verbose tool outputs while keeping critical findings
+- Maintain version numbers, specific technologies identified
+- Keep exact error messages that might indicate vulnerabilities
+- Compress repetitive or similar findings into consolidated form
+
+Remember: Another security agent will use this summary to continue the assessment.
+They must be able to pick up exactly where you left off without losing any
+operational advantage or context needed to find vulnerabilities.
+
+CONVERSATION SEGMENT TO SUMMARIZE:
+{conversation}
+
+Provide a technically precise summary that preserves all operational security context while
+keeping the summary concise and to the point."""
+
+
+def _count_tokens(text: str, model: str) -> int:
+    try:
+        count = litellm.token_counter(model=model, text=text)
+        return int(count)
+    except Exception:
+        logger.exception("Failed to count tokens")
+        return len(text) // 4  # Rough estimate
+
+
+def _get_message_tokens(msg: dict[str, Any], model: str) -> int:
+    content = msg.get("content", "")
+    if isinstance(content, str):
+        return _count_tokens(content, model)
+    if isinstance(content, list):
+        return sum(
+            _count_tokens(item.get("text", ""), model)
+            for item in content
+            if isinstance(item, dict) and item.get("type") == "text"
+        )
+    return 0
+
+
+def _extract_message_text(msg: dict[str, Any]) -> str:
+    content = msg.get("content", "")
+    if isinstance(content, str):
+        return content
+
+    if isinstance(content, list):
+        parts = []
+        for item in content:
+            if isinstance(item, dict):
+                if item.get("type") == "text":
+                    parts.append(item.get("text", ""))
+                elif item.get("type") == "image_url":
+                    parts.append("[IMAGE]")
+        return " ".join(parts)
+
+    return str(content)
+
+
+def _summarize_messages(
+    messages: list[dict[str, Any]],
+    model: str,
+    timeout: int = 30,
+) -> dict[str, Any]:
+    if not messages:
+        empty_summary = "<context_summary message_count='0'>{text}</context_summary>"
+        return {
+            "role": "user",
+            "content": empty_summary.format(text="No messages to summarize"),
+        }
+
+    formatted = []
+    for msg in messages:
+        role = msg.get("role", "unknown")
+        text = _extract_message_text(msg)
+        formatted.append(f"{role}: {text}")
+
+    conversation = "\n".join(formatted)
+    prompt = SUMMARY_PROMPT_TEMPLATE.format(conversation=conversation)
+
+    _, api_key, api_base = resolve_llm_config()
+
+    try:
+        completion_args: dict[str, Any] = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt}],
+            "timeout": timeout,
+        }
+        if api_key:
+            completion_args["api_key"] = api_key
+        if api_base:
+            completion_args["api_base"] = api_base
+
+        response = litellm.completion(**completion_args)
+        summary = response.choices[0].message.content or ""
+        if not summary.strip():
+            return messages[0]
+        summary_msg = "<context_summary message_count='{count}'>{text}</context_summary>"
+        return {
+            "role": "user",
+            "content": summary_msg.format(count=len(messages), text=summary),
+        }
+    except Exception:
+        logger.exception("Failed to summarize messages")
+        return messages[0]
+
+
+def _handle_images(messages: list[dict[str, Any]], max_images: int) -> None:
+    image_count = 0
+    for msg in reversed(messages):
+        content = msg.get("content", [])
+        if isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict) and item.get("type") == "image_url":
+                    if image_count >= max_images:
+                        item.update(
+                            {
+                                "type": "text",
+                                "text": "[Previously attached image removed to preserve context]",
+                            }
+                        )
+                    else:
+                        image_count += 1
+
+
+class MemoryCompressor:
+    def __init__(
+        self,
+        max_images: int = 3,
+        model_name: str | None = None,
+        timeout: int | None = None,
+    ):
+        self.max_images = max_images
+        self.model_name = model_name or Config.get("strix_llm")
+        self.timeout = timeout or int(Config.get("strix_memory_compressor_timeout") or "120")
+
+        if not self.model_name:
+            raise ValueError("STRIX_LLM environment variable must be set and not empty")
+
+    def compress_history(
+        self,
+        messages: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        """Compress conversation history to stay within token limits.
+
+        Strategy:
+        1. Handle image limits first
+        2. Keep all system messages
+        3. Keep minimum recent messages
+        4. Summarize older messages when total tokens exceed limit
+
+        The compression preserves:
+        - All system messages unchanged
+        - Most recent messages intact
+        - Critical security context in summaries
+        - Recent images for visual context
+        - Technical details and findings
+        """
+        if not messages:
+            return messages
+
+        _handle_images(messages, self.max_images)
+
+        system_msgs = []
+        regular_msgs = []
+        for msg in messages:
+            if msg.get("role") == "system":
+                system_msgs.append(msg)
+            else:
+                regular_msgs.append(msg)
+
+        recent_msgs = regular_msgs[-MIN_RECENT_MESSAGES:]
+        old_msgs = regular_msgs[:-MIN_RECENT_MESSAGES]
+
+        # Type assertion since we ensure model_name is not None in __init__
+        model_name: str = self.model_name  # type: ignore[assignment]
+
+        total_tokens = sum(
+            _get_message_tokens(msg, model_name) for msg in system_msgs + regular_msgs
+        )
+
+        if total_tokens <= MAX_TOTAL_TOKENS * 0.9:
+            return messages
+
+        compressed = []
+        chunk_size = 10
+        for i in range(0, len(old_msgs), chunk_size):
+            chunk = old_msgs[i : i + chunk_size]
+            summary = _summarize_messages(chunk, model_name, self.timeout)
+            if summary:
+                compressed.append(summary)
+
+        return system_msgs + compressed + recent_msgs

strix/llm/utils.py

@@ -0,0 +1,160 @@
+import html
+import re
+from typing import Any
+
+
+_INVOKE_OPEN = re.compile(r'<invoke\s+name=["\']([^"\']+)["\']>')
+_PARAM_NAME_ATTR = re.compile(r'<parameter\s+name=["\']([^"\']+)["\']>')
+_FUNCTION_CALLS_TAG = re.compile(r"</?function_calls>")
+_STRIP_TAG_QUOTES = re.compile(r"<(function|parameter)\s*=\s*([^>]*?)>")
+
+
+def normalize_tool_format(content: str) -> str:
+    """Convert alternative tool-call XML formats to the expected one.
+
+    Handles:
+      <function_calls>...</function_calls>  → stripped
+      <invoke name="X">                     → <function=X>
+      <parameter name="X">                  → <parameter=X>
+      </invoke>                             → </function>
+      <function="X">                        → <function=X>
+      <parameter="X">                       → <parameter=X>
+    """
+    if "<invoke" in content or "<function_calls" in content:
+        content = _FUNCTION_CALLS_TAG.sub("", content)
+        content = _INVOKE_OPEN.sub(r"<function=\1>", content)
+        content = _PARAM_NAME_ATTR.sub(r"<parameter=\1>", content)
+        content = content.replace("</invoke>", "</function>")
+
+    return _STRIP_TAG_QUOTES.sub(
+        lambda m: f"<{m.group(1)}={m.group(2).strip().strip(chr(34) + chr(39))}>", content
+    )
+
+
+STRIX_MODEL_MAP: dict[str, str] = {
+    "claude-sonnet-4.6": "anthropic/claude-sonnet-4-6",
+    "claude-opus-4.6": "anthropic/claude-opus-4-6",
+    "gpt-5.2": "openai/gpt-5.2",
+    "gpt-5.1": "openai/gpt-5.1",
+    "gpt-5.4": "openai/gpt-5.4",
+    "gemini-3-pro-preview": "gemini/gemini-3-pro-preview",
+    "gemini-3-flash-preview": "gemini/gemini-3-flash-preview",
+    "glm-5": "openrouter/z-ai/glm-5",
+    "glm-4.7": "openrouter/z-ai/glm-4.7",
+}
+
+
+def resolve_strix_model(model_name: str | None) -> tuple[str | None, str | None]:
+    """Resolve a strix/ model into names for API calls and capability lookups.
+
+    Returns (api_model, canonical_model):
+    - api_model: openai/<base> for API calls (Strix API is OpenAI-compatible)
+    - canonical_model: actual provider model name for litellm capability lookups
+    Non-strix models return the same name for both.
+    """
+    if not model_name or not model_name.startswith("strix/"):
+        return model_name, model_name
+
+    base_model = model_name[6:]
+    api_model = f"openai/{base_model}"
+    canonical_model = STRIX_MODEL_MAP.get(base_model, api_model)
+    return api_model, canonical_model
+
+
+def _truncate_to_first_function(content: str) -> str:
+    if not content:
+        return content
+
+    function_starts = [
+        match.start() for match in re.finditer(r"<function=|<invoke\s+name=", content)
+    ]
+
+    if len(function_starts) >= 2:
+        second_function_start = function_starts[1]
+
+        return content[:second_function_start].rstrip()
+
+    return content
+
+
+def parse_tool_invocations(content: str) -> list[dict[str, Any]] | None:
+    content = normalize_tool_format(content)
+    content = fix_incomplete_tool_call(content)
+
+    tool_invocations: list[dict[str, Any]] = []
+
+    fn_regex_pattern = r"<function=([^>]+)>\n?(.*?)</function>"
+    fn_param_regex_pattern = r"<parameter=([^>]+)>(.*?)</parameter>"
+
+    fn_matches = re.finditer(fn_regex_pattern, content, re.DOTALL)
+
+    for fn_match in fn_matches:
+        fn_name = fn_match.group(1)
+        fn_body = fn_match.group(2)
+
+        param_matches = re.finditer(fn_param_regex_pattern, fn_body, re.DOTALL)
+
+        args = {}
+        for param_match in param_matches:
+            param_name = param_match.group(1)
+            param_value = param_match.group(2).strip()
+
+            param_value = html.unescape(param_value)
+            args[param_name] = param_value
+
+        tool_invocations.append({"toolName": fn_name, "args": args})
+
+    return tool_invocations if tool_invocations else None
+
+
+def fix_incomplete_tool_call(content: str) -> str:
+    """Fix incomplete tool calls by adding missing closing tag.
+
+    Handles both ``<function=…>`` and ``<invoke name="…">`` formats.
+    """
+    has_open = "<function=" in content or "<invoke " in content
+    count_open = content.count("<function=") + content.count("<invoke ")
+    has_close = "</function>" in content or "</invoke>" in content
+    if has_open and count_open == 1 and not has_close:
+        content = content.rstrip()
+        content = content + "function>" if content.endswith("</") else content + "\n</function>"
+    return content
+
+
+def format_tool_call(tool_name: str, args: dict[str, Any]) -> str:
+    xml_parts = [f"<function={tool_name}>"]
+
+    for key, value in args.items():
+        xml_parts.append(f"<parameter={key}>{value}</parameter>")
+
+    xml_parts.append("</function>")
+
+    return "\n".join(xml_parts)
+
+
+def clean_content(content: str) -> str:
+    if not content:
+        return ""
+
+    content = normalize_tool_format(content)
+    content = fix_incomplete_tool_call(content)
+
+    tool_pattern = r"<function=[^>]+>.*?</function>"
+    cleaned = re.sub(tool_pattern, "", content, flags=re.DOTALL)
+
+    incomplete_tool_pattern = r"<function=[^>]+>.*$"
+    cleaned = re.sub(incomplete_tool_pattern, "", cleaned, flags=re.DOTALL)
+
+    partial_tag_pattern = r"<f(?:u(?:n(?:c(?:t(?:i(?:o(?:n(?:=(?:[^>]*)?)?)?)?)?)?)?)?)?$"
+    cleaned = re.sub(partial_tag_pattern, "", cleaned)
+
+    hidden_xml_patterns = [
+        r"<inter_agent_message>.*?</inter_agent_message>",
+        r"<agent_completion_report>.*?</agent_completion_report>",
+    ]
+    for pattern in hidden_xml_patterns:
+        cleaned = re.sub(pattern, "", cleaned, flags=re.DOTALL | re.IGNORECASE)
+
+    cleaned = re.sub(r"\n\s*\n", "\n\n", cleaned)
+
+    return cleaned.strip()

strix/report/__init__.py

@@ -1,12 +0,0 @@
-"""Report/finding helpers."""
-
-from strix.report.dedupe import check_duplicate
-from strix.report.state import ReportState, get_global_report_state, set_global_report_state
-
-
-__all__ = [
-    "ReportState",
-    "check_duplicate",
-    "get_global_report_state",
-    "set_global_report_state",
-]

strix/report/dedupe.py

@@ -1,240 +0,0 @@
-"""SDK-native vulnerability-report deduplication."""
-
-from __future__ import annotations
-
-import json
-import logging
-from typing import TYPE_CHECKING, Any
-
-from agents.model_settings import ModelSettings
-from agents.models.interface import ModelTracing
-from openai.types.responses import ResponseOutputMessage
-
-from strix.config import load_settings
-from strix.config.models import (
-    DEFAULT_MODEL_RETRY,
-    StrixProvider,
-    configure_sdk_model_defaults,
-)
-from strix.report.state import get_global_report_state
-
-
-if TYPE_CHECKING:
-    from agents.items import ModelResponse
-
-
-logger = logging.getLogger(__name__)
-
-DEDUPE_SYSTEM_PROMPT = """You are an expert vulnerability report deduplication judge.
-Your task is to determine if a candidate vulnerability report describes the SAME vulnerability
-as any existing report.
-
-CRITICAL DEDUPLICATION RULES:
-
-1. SAME VULNERABILITY means:
-   - Same root cause (e.g., "missing input validation" not just "SQL injection")
-   - Same affected component/endpoint/file (exact match or clear overlap)
-   - Same exploitation method or attack vector
-   - Would be fixed by the same code change/patch
-
-2. NOT DUPLICATES if:
-   - Different endpoints even with same vulnerability type (e.g., SQLi in /login vs /search)
-   - Different parameters in same endpoint (e.g., XSS in 'name' vs 'comment' field)
-   - Different root causes (e.g., stored XSS vs reflected XSS in same field)
-   - Different severity levels due to different impact
-   - One is authenticated, other is unauthenticated
-
-3. ARE DUPLICATES even if:
-   - Titles are worded differently
-   - Descriptions have different level of detail
-   - PoC uses different payloads but exploits same issue
-   - One report is more thorough than another
-   - Minor variations in technical analysis
-
-COMPARISON GUIDELINES:
-- Focus on the technical root cause, not surface-level similarities
-- Same vulnerability type (SQLi, XSS) doesn't mean duplicate - location matters
-- Consider the fix: would fixing one also fix the other?
-- When uncertain, lean towards NOT duplicate
-
-FIELDS TO ANALYZE:
-- title, description: General vulnerability info
-- target, endpoint, method: Exact location of vulnerability
-- technical_analysis: Root cause details
-- poc_description: How it's exploited
-- impact: What damage it can cause
-
-Respond with a single JSON object and nothing else:
-
-{
-  "is_duplicate": true,
-  "duplicate_id": "vuln-0001",
-  "confidence": 0.95,
-  "reason": "Both reports describe SQL injection in /api/login via the username parameter"
-}
-
-Or, if not a duplicate:
-
-{
-  "is_duplicate": false,
-  "duplicate_id": "",
-  "confidence": 0.90,
-  "reason": "Different endpoints: candidate is /api/search, existing is /api/login"
-}
-
-Rules:
-- ``is_duplicate`` is a boolean.
-- ``duplicate_id`` is the exact id from existing reports, or "" if not a duplicate.
-- ``confidence`` is a number between 0 and 1.
-- ``reason`` is a specific explanation mentioning endpoint/parameter/root cause.
-- Output ONLY the JSON object — no surrounding prose, no code fences."""
-
-
-def _prepare_report_for_comparison(report: dict[str, Any]) -> dict[str, Any]:
-    relevant_fields = [
-        "id",
-        "title",
-        "description",
-        "impact",
-        "target",
-        "technical_analysis",
-        "poc_description",
-        "endpoint",
-        "method",
-    ]
-
-    cleaned = {}
-    for field in relevant_fields:
-        if report.get(field):
-            value = report[field]
-            if isinstance(value, str) and len(value) > 8000:
-                value = value[:8000] + "...[truncated]"
-            cleaned[field] = value
-
-    return cleaned
-
-
-def _parse_dedupe_response(content: str) -> dict[str, Any]:
-    text = content.strip()
-    if text.startswith("```"):
-        text = text.strip("`")
-        if text.lower().startswith("json"):
-            text = text[4:]
-        text = text.strip()
-    start = text.find("{")
-    end = text.rfind("}")
-    if start == -1 or end == -1 or end <= start:
-        raise ValueError(f"No JSON object found in dedupe response: {content[:500]}")
-    parsed = json.loads(text[start : end + 1])
-
-    duplicate_id = str(parsed.get("duplicate_id") or "")[:64]
-    reason = str(parsed.get("reason") or "")[:500]
-    try:
-        confidence = float(parsed.get("confidence", 0.0))
-    except (TypeError, ValueError):
-        confidence = 0.0
-
-    return {
-        "is_duplicate": bool(parsed.get("is_duplicate", False)),
-        "duplicate_id": duplicate_id,
-        "confidence": confidence,
-        "reason": reason,
-    }
-
-
-def _extract_text(response: ModelResponse) -> str:
-    parts: list[str] = []
-    for item in response.output:
-        if not isinstance(item, ResponseOutputMessage):
-            continue
-        for chunk in item.content:
-            text = getattr(chunk, "text", None)
-            if text:
-                parts.append(text)
-    return "".join(parts)
-
-
-async def check_duplicate(
-    candidate: dict[str, Any], existing_reports: list[dict[str, Any]]
-) -> dict[str, Any]:
-    if not existing_reports:
-        return {
-            "is_duplicate": False,
-            "duplicate_id": "",
-            "confidence": 1.0,
-            "reason": "No existing reports to compare against",
-        }
-
-    try:
-        settings = load_settings()
-        model_name = settings.llm.model
-        if not model_name:
-            return {
-                "is_duplicate": False,
-                "duplicate_id": "",
-                "confidence": 0.0,
-                "reason": "STRIX_LLM not configured; skipping dedupe check",
-            }
-
-        candidate_cleaned = _prepare_report_for_comparison(candidate)
-        existing_cleaned = [_prepare_report_for_comparison(r) for r in existing_reports]
-        comparison_data = {"candidate": candidate_cleaned, "existing_reports": existing_cleaned}
-
-        user_msg = (
-            f"Compare this candidate vulnerability against existing reports:\n\n"
-            f"{json.dumps(comparison_data, indent=2)}\n\n"
-            f"Respond with ONLY the JSON object described in the system prompt."
-        )
-
-        configure_sdk_model_defaults(settings)
-        resolved_model = model_name.strip()
-        model = StrixProvider().get_model(resolved_model)
-        response = await model.get_response(
-            system_instructions=DEDUPE_SYSTEM_PROMPT,
-            input=user_msg,
-            model_settings=ModelSettings(retry=DEFAULT_MODEL_RETRY, include_usage=True),
-            tools=[],
-            output_schema=None,
-            handoffs=[],
-            tracing=ModelTracing.DISABLED,
-            previous_response_id=None,
-            conversation_id=None,
-            prompt=None,
-        )
-        report_state = get_global_report_state()
-        if report_state is not None:
-            report_state.record_sdk_usage(
-                agent_id="dedupe",
-                agent_name="dedupe",
-                model=resolved_model,
-                usage=response.usage,
-            )
-        content = _extract_text(response)
-        if not content:
-            return {
-                "is_duplicate": False,
-                "duplicate_id": "",
-                "confidence": 0.0,
-                "reason": "Empty response from LLM",
-            }
-
-        result = _parse_dedupe_response(content)
-
-        logger.info(
-            "Deduplication check: is_duplicate=%s, confidence=%.2f, reason=%s",
-            result["is_duplicate"],
-            result["confidence"],
-            result["reason"][:100],
-        )
-
-    except Exception as e:
-        logger.exception("Error during vulnerability deduplication check")
-        return {
-            "is_duplicate": False,
-            "duplicate_id": "",
-            "confidence": 0.0,
-            "reason": f"Deduplication check failed: {e}",
-            "error": str(e),
-        }
-    else:
-        return result

strix/report/state.py

@@ -1,535 +0,0 @@
-import json
-import logging
-import subprocess
-from collections.abc import Callable
-from datetime import UTC, datetime
-from importlib.metadata import PackageNotFoundError, version
-from pathlib import Path
-from typing import Any, Optional, cast
-from uuid import uuid4
-
-from agents.usage import Usage
-
-from strix.core.paths import run_dir_for
-from strix.report.sarif import write_sarif
-from strix.report.usage import LLMUsageLedger
-from strix.report.writer import (
-    read_run_record,
-    write_executive_report,
-    write_run_record,
-    write_vulnerabilities,
-)
-from strix.telemetry import posthog, scarf
-
-
-logger = logging.getLogger(__name__)
-
-_global_report_state: Optional["ReportState"] = None
-
-
-def _strix_version() -> str | None:
-    """Best-effort package version for the SARIF tool.driver.version field."""
-    try:
-        return version("strix-agent")
-    except PackageNotFoundError:
-        return None
-
-
-def _parse_repo_full_name(uri: str) -> str | None:
-    """Extract ``owner/repo`` from a git URL or slug, else None."""
-    text = uri.strip().removesuffix(".git")
-    if not text:
-        return None
-    if "@" in text and ":" in text.split("@", 1)[1]:
-        # scp-style: git@host:owner/repo
-        text = text.split("@", 1)[1].split(":", 1)[1]
-    elif "://" in text:
-        # https://host/owner/repo
-        host_and_path = text.split("://", 1)[1]
-        text = host_and_path.split("/", 1)[1] if "/" in host_and_path else host_and_path
-    parts = [p for p in text.split("/") if p]
-    if len(parts) >= 2:
-        return "/".join(parts[-2:])
-    return None
-
-
-def _git_head(repo_path: str) -> tuple[str | None, str | None]:
-    """Best-effort ``(commit_sha, branch)`` for a cloned repo, or ``(None, None)``.
-
-    Used to populate SARIF versionControlProvenance. Failures (missing git,
-    non-repo path, detached HEAD, timeout) degrade to None so the SARIF
-    emit is never blocked by a provenance lookup.
-    """
-    path = Path(repo_path)
-    if not path.is_dir():
-        return None, None
-
-    def _run(args: list[str]) -> str | None:
-        try:
-            result = subprocess.run(  # noqa: S603
-                ["git", "-C", str(path), *args],  # noqa: S607
-                capture_output=True,
-                text=True,
-                check=False,
-                timeout=5,
-            )
-        except (OSError, subprocess.SubprocessError):
-            return None
-        if result.returncode != 0:
-            return None
-        return result.stdout.strip() or None
-
-    commit = _run(["rev-parse", "HEAD"])
-    branch = _run(["rev-parse", "--abbrev-ref", "HEAD"])
-    if branch == "HEAD":  # detached HEAD carries no branch name
-        branch = None
-    return commit, branch
-
-
-def get_global_report_state() -> Optional["ReportState"]:
-    return _global_report_state
-
-
-def set_global_report_state(report_state: "ReportState") -> None:
-    global _global_report_state  # noqa: PLW0603
-    _global_report_state = report_state
-
-
-class ReportState:
-    """Per-scan product artifact state plus artifact writer.
-
-    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.
-
-    It does not consume SDK tracing processors.
-    """
-
-    def __init__(self, run_name: str | None = None):
-        self.run_name = run_name
-        self.run_id = run_name or f"run-{uuid4().hex[:8]}"
-        self.start_time = datetime.now(UTC).isoformat()
-        self.end_time: str | None = None
-
-        self.vulnerability_reports: list[dict[str, Any]] = []
-        self.final_scan_result: str | None = None
-
-        self.scan_results: dict[str, Any] | None = None
-        self.scan_config: dict[str, Any] | None = None
-        self._llm_usage = LLMUsageLedger()
-        self.run_record: dict[str, Any] = {
-            "run_id": self.run_id,
-            "run_name": self.run_name,
-            "start_time": self.start_time,
-            "end_time": None,
-            "status": "running",
-            "targets_info": [],
-            "llm_usage": self._build_llm_usage_record(),
-        }
-        self._run_dir: Path | None = None
-        self._saved_vuln_ids: set[str] = set()
-
-        self.caido_url: str | None = None
-        self.vulnerability_found_callback: Callable[[dict[str, Any]], None] | None = None
-
-        self._sarif_repo_ctx: dict[str, Any] | None = None
-        self._sarif_repo_ctx_ready: bool = False
-
-    def get_run_dir(self) -> Path:
-        if self._run_dir is None:
-            run_dir_name = self.run_name if self.run_name else self.run_id
-            self._run_dir = run_dir_for(run_dir_name)
-            self._run_dir.mkdir(parents=True, exist_ok=True)
-
-        return self._run_dir
-
-    def hydrate_from_run_dir(self) -> None:
-        """Reload prior-scan state from ``{run_dir}/`` for resume.
-
-        Restores:
-
-        - ``vulnerability_reports`` from ``vulnerabilities.json`` so
-          :meth:`add_vulnerability_report` doesn't allocate a colliding
-          ``vuln-0001`` and overwrite the prior on-disk MD.
-        - ``run_record`` from ``run.json`` so timestamps, run inputs,
-          status, and final report state have one public source of truth.
-
-        Idempotent on missing files (fresh runs land here too via the
-        same code path). **Raises on corruption** — silently swallowing
-        a corrupt ``vulnerabilities.json`` would let the next vuln
-        allocate ``vuln-0001`` and overwrite the prior MD on disk
-        (data loss). Caller is expected to fail the run loud and let
-        the user inspect ``{run_dir}`` or pick a fresh ``--run-name``.
-        """
-        run_dir = self.get_run_dir()
-
-        data = read_run_record(run_dir)
-        if data:
-            self.run_record.update(data)
-            if isinstance(data.get("start_time"), str):
-                self.start_time = data["start_time"]
-            if isinstance(data.get("end_time"), str):
-                self.end_time = data["end_time"]
-            scan_results = data.get("scan_results")
-            if isinstance(scan_results, dict):
-                self.scan_results = scan_results
-                self.final_scan_result = self._format_final_scan_result(scan_results)
-            self._hydrate_llm_usage(data.get("llm_usage"))
-            logger.info("report state hydrated run.json from %s", run_dir)
-
-        json_path = run_dir / "vulnerabilities.json"
-        if json_path.exists():
-            try:
-                data = json.loads(json_path.read_text(encoding="utf-8"))
-            except (OSError, json.JSONDecodeError) as exc:
-                raise RuntimeError(
-                    f"vulnerabilities.json at {json_path} is corrupt ({exc}); "
-                    f"refusing to start fresh — that would overwrite prior "
-                    f"vulnerability MDs on disk. Inspect or delete the run dir.",
-                ) from exc
-            if not isinstance(data, list):
-                raise RuntimeError(
-                    f"vulnerabilities.json at {json_path} is not a list",
-                )
-            self.vulnerability_reports = [r for r in data if isinstance(r, dict)]
-            for r in self.vulnerability_reports:
-                rid = r.get("id")
-                if isinstance(rid, str):
-                    self._saved_vuln_ids.add(rid)
-            logger.info(
-                "report state hydrated %d vulnerability report(s)",
-                len(self.vulnerability_reports),
-            )
-
-    def add_vulnerability_report(
-        self,
-        title: str,
-        severity: str,
-        description: str | None = None,
-        impact: str | None = None,
-        target: str | None = None,
-        technical_analysis: str | None = None,
-        poc_description: str | None = None,
-        poc_script_code: str | None = None,
-        remediation_steps: str | None = None,
-        cvss: float | None = None,
-        cvss_breakdown: dict[str, str] | None = None,
-        endpoint: str | None = None,
-        method: str | None = None,
-        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}"
-
-        report: dict[str, Any] = {
-            "id": report_id,
-            "title": title.strip(),
-            "severity": severity.lower().strip(),
-            "timestamp": datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S UTC"),
-        }
-
-        if description:
-            report["description"] = description.strip()
-        if impact:
-            report["impact"] = impact.strip()
-        if target:
-            report["target"] = target.strip()
-        if technical_analysis:
-            report["technical_analysis"] = technical_analysis.strip()
-        if poc_description:
-            report["poc_description"] = poc_description.strip()
-        if poc_script_code:
-            report["poc_script_code"] = poc_script_code.strip()
-        if remediation_steps:
-            report["remediation_steps"] = remediation_steps.strip()
-        if cvss is not None:
-            report["cvss"] = cvss
-        if cvss_breakdown:
-            report["cvss_breakdown"] = cvss_breakdown
-        if endpoint:
-            report["endpoint"] = endpoint.strip()
-        if method:
-            report["method"] = method.strip()
-        if cve:
-            report["cve"] = cve.strip()
-        if cwe:
-            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_name
-
-        self.vulnerability_reports.append(report)
-        logger.info(f"Added vulnerability report: {report_id} - {title}")
-        posthog.finding(severity)
-        scarf.finding(severity)
-
-        if self.vulnerability_found_callback:
-            self.vulnerability_found_callback(report)
-
-        self.save_run_data()
-        return report_id
-
-    def get_existing_vulnerabilities(self) -> list[dict[str, Any]]:
-        return list(self.vulnerability_reports)
-
-    def record_sdk_usage(
-        self,
-        *,
-        agent_id: str,
-        usage: Usage | None,
-        agent_name: str | None = None,
-        model: str | None = None,
-    ) -> None:
-        """Record SDK-native token usage for one completed model run/cycle."""
-        if self._llm_usage.record(
-            agent_id=agent_id,
-            agent_name=agent_name,
-            model=model,
-            usage=usage,
-        ):
-            self.save_run_data()
-
-    def record_observed_llm_cost(self, cost: float) -> None:
-        self._llm_usage.record_observed_cost(cost)
-
-    def get_total_llm_usage(self) -> dict[str, Any]:
-        return dict(self.run_record.get("llm_usage") or self._build_llm_usage_record())
-
-    def get_total_llm_cost(self) -> float:
-        """Live accumulated LLM cost, independent of the persisted run-record snapshot."""
-        return self._llm_usage.total_cost
-
-    def update_scan_final_fields(
-        self,
-        executive_summary: str,
-        methodology: str,
-        technical_analysis: str,
-        recommendations: str,
-    ) -> None:
-        self.scan_results = {
-            "scan_completed": True,
-            "executive_summary": executive_summary.strip(),
-            "methodology": methodology.strip(),
-            "technical_analysis": technical_analysis.strip(),
-            "recommendations": recommendations.strip(),
-            "success": True,
-        }
-
-        self.final_scan_result = self._format_final_scan_result(self.scan_results)
-        self.run_record["scan_results"] = self.scan_results
-
-        logger.info("Updated scan final fields")
-        self.save_run_data(mark_complete=True)
-        posthog.end(self, exit_reason="finished_by_tool")
-        scarf.end(self, exit_reason="finished_by_tool")
-
-    def set_scan_config(self, config: dict[str, Any]) -> None:
-        self.scan_config = config
-        self.run_record["status"] = "running"
-        self.run_record["end_time"] = None
-        self.run_record.pop("scan_results", None)
-        self.end_time = None
-        self.scan_results = None
-        self.final_scan_result = None
-        self.run_record.update(
-            {
-                "targets_info": config.get("targets", []),
-                "instruction": config.get("user_instructions", ""),
-                "scan_mode": config.get("scan_mode", "deep"),
-                "diff_scope": config.get("diff_scope", {"active": False}),
-                "non_interactive": bool(config.get("non_interactive", False)),
-                "local_sources": config.get("local_sources", []),
-                "scope_mode": config.get("scope_mode", "auto"),
-                "diff_base": config.get("diff_base"),
-            }
-        )
-
-    def save_run_data(self, mark_complete: bool = False, status: str | None = None) -> None:
-        if mark_complete:
-            self.end_time = datetime.now(UTC).isoformat()
-            self.run_record["end_time"] = self.end_time
-            self.run_record["status"] = "completed"
-        elif status and self.run_record.get("status") != "completed":
-            current_status = self.run_record.get("status")
-            if status == "stopped" and current_status in {"failed", "interrupted"}:
-                status = str(current_status)
-            if self.end_time is None:
-                self.end_time = datetime.now(UTC).isoformat()
-            self.run_record["end_time"] = self.end_time
-            self.run_record["status"] = status
-
-        self._sync_llm_usage_record()
-        self._save_artifacts()
-
-    def cleanup(self, status: str = "stopped") -> None:
-        self.save_run_data(status=status)
-
-    def _format_final_scan_result(self, scan_results: dict[str, Any]) -> str:
-        return f"""# Executive Summary
-
-{str(scan_results.get("executive_summary", "")).strip()}
-
-# Methodology
-
-{str(scan_results.get("methodology", "")).strip()}
-
-# Technical Analysis
-
-{str(scan_results.get("technical_analysis", "")).strip()}
-
-# Recommendations
-
-{str(scan_results.get("recommendations", "")).strip()}
-"""
-
-    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)
-
-            if self.final_scan_result:
-                write_executive_report(run_dir, self.final_scan_result)
-
-            if self.vulnerability_reports:
-                write_vulnerabilities(run_dir, self.vulnerability_reports, self._saved_vuln_ids)
-
-            # SARIF 2.1.0 emitter for CI / ASPM integration. Always emit (even
-            # empty) so a clean run overwrites a prior findings.sarif rather than
-            # leaving a stale one — codeql-action's "absent from new submission →
-            # fixed" needs the fresh empty doc to auto-resolve alerts. Isolated
-            # in its own try: a SARIF-build error must NEVER break the CSV/MD/
-            # run-record path (the emitter's own contract).
-            try:
-                write_sarif(
-                    run_dir,
-                    self.vulnerability_reports,
-                    tool_version=_strix_version(),
-                    repository_context=self._sarif_repository_context(),
-                )
-            except Exception:
-                logger.exception("SARIF emit failed (non-fatal; CSV/MD unaffected)")
-
-            write_run_record(run_dir, self.run_record)
-
-            logger.info("Essential scan data saved to: %s", run_dir)
-        except (OSError, RuntimeError):
-            logger.exception("Failed to save scan data")
-
-    def _sarif_repository_context(self) -> dict[str, Any] | None:
-        """Repo/commit/branch context for SARIF provenance (repo scans only).
-
-        Cached after first derivation — ``_save_artifacts`` runs on every
-        state save, and the git lookup only needs to happen once per run.
-        Returns None for URL / IP (DAST) targets that have no repository.
-        """
-        if not self._sarif_repo_ctx_ready:
-            self._sarif_repo_ctx = self._derive_repository_context()
-            self._sarif_repo_ctx_ready = True
-        return self._sarif_repo_ctx
-
-    def _derive_repository_context(self) -> dict[str, Any] | None:
-        targets = self.run_record.get("targets_info") or []
-        if not isinstance(targets, list):
-            return None
-        repo_targets = [
-            target
-            for target in targets
-            if isinstance(target, dict) and target.get("type") == "repository"
-        ]
-        # Provenance binds the whole run to one repo; with multiple repo targets
-        # that's ambiguous, so omit it rather than mis-attributing later repos'
-        # findings to the first repo's URI/commit.
-        if len(repo_targets) != 1:
-            return None
-        target = repo_targets[0]
-        details = target.get("details") or {}
-        if not isinstance(details, dict):
-            return None
-        uri = details.get("target_repo")
-        if not isinstance(uri, str) or not uri.strip():
-            return None
-
-        context: dict[str, Any] = {"repositoryUri": uri.strip()}
-        full_name = _parse_repo_full_name(uri)
-        if full_name:
-            context["repositoryFullName"] = full_name
-        cloned = details.get("cloned_repo_path")
-        if isinstance(cloned, str) and cloned.strip():
-            commit, branch = _git_head(cloned.strip())
-            if commit:
-                context["commitSha"] = commit
-            if branch:
-                context["branch"] = branch
-                context["ref"] = f"refs/heads/{branch}"
-        return context
-
-    def _sync_llm_usage_record(self) -> None:
-        self.run_record["llm_usage"] = self._build_llm_usage_record()
-
-    def _build_llm_usage_record(self) -> dict[str, Any]:
-        return self._llm_usage.to_record()
-
-    def _hydrate_llm_usage(self, raw_usage: Any) -> None:
-        self._llm_usage.hydrate(raw_usage)
-        self._sync_llm_usage_record()
-
-
-def litellm_cost_callback(
-    kwargs: Any,
-    completion_response: Any,
-    _start_time: Any = None,
-    _end_time: Any = None,
-) -> None:
-    """LiteLLM ``success_callback`` adapter; forwards observed cost to the active scan."""
-    cost: float | None = None
-    raw = kwargs.get("response_cost") if isinstance(kwargs, dict) else None
-    if isinstance(raw, int | float) and raw > 0:
-        cost = float(raw)
-
-    if cost is None:
-        hidden = getattr(completion_response, "_hidden_params", None) or {}
-        candidate = hidden.get("response_cost") if isinstance(hidden, dict) else None
-        if isinstance(candidate, int | float) and candidate > 0:
-            cost = float(candidate)
-        else:
-            headers = hidden.get("additional_headers") or {} if isinstance(hidden, dict) else {}
-            raw = (
-                headers.get("llm_provider-x-litellm-response-cost")
-                if isinstance(headers, dict)
-                else None
-            )
-            try:
-                value = float(raw) if raw is not None else None
-            except (TypeError, ValueError):
-                value = None
-            if value is not None and value > 0:
-                cost = value
-
-    if cost is None:
-        usage: Any = getattr(completion_response, "usage", None)
-        if usage is None and isinstance(completion_response, dict):
-            usage = cast("dict[str, Any]", completion_response).get("usage")
-        usage_cost: Any
-        if isinstance(usage, dict):
-            usage_cost = cast("dict[str, Any]", usage).get("cost")
-        else:
-            usage_cost = getattr(usage, "cost", None)
-        if isinstance(usage_cost, int | float) and usage_cost > 0:
-            cost = float(usage_cost)
-
-    if cost is None or cost <= 0:
-        return
-    report_state = get_global_report_state()
-    if report_state is None:
-        return
-    try:
-        report_state.record_observed_llm_cost(cost)
-    except Exception:
-        logger.exception("Failed to record observed LiteLLM cost")

strix/report/usage.py

@@ -1,262 +0,0 @@
-"""SDK-native LLM usage aggregation for scan reports."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from agents.usage import Usage, deserialize_usage, serialize_usage
-
-
-logger = logging.getLogger(__name__)
-
-
-class LLMUsageLedger:
-    """Aggregate SDK ``Usage`` objects and attach best-effort cost estimates."""
-
-    def __init__(self) -> None:
-        self._total_usage = Usage()
-        self._agent_usage: dict[str, Usage] = {}
-        self._agent_metadata: dict[str, dict[str, str]] = {}
-        self._total_cost = 0.0
-
-    def record(
-        self,
-        *,
-        agent_id: str,
-        usage: Usage | None,
-        agent_name: str | None = None,
-        model: str | None = None,
-    ) -> bool:
-        if usage is None or not _usage_has_activity(usage):
-            return False
-
-        normalized_agent_id = str(agent_id or "unknown")
-        self._total_usage.add(usage)
-        self._agent_usage.setdefault(normalized_agent_id, Usage()).add(usage)
-
-        metadata = self._agent_metadata.setdefault(normalized_agent_id, {})
-        if agent_name:
-            metadata["agent_name"] = agent_name
-        if model:
-            metadata["model"] = model
-
-        if not _is_litellm_routed(model):
-            estimated = _estimate_litellm_cost(usage, model)
-            if estimated:
-                self._total_cost += estimated
-
-        return True
-
-    def record_observed_cost(self, cost: float) -> None:
-        if isinstance(cost, int | float) and cost > 0:
-            self._total_cost += float(cost)
-
-    @property
-    def total_cost(self) -> float:
-        return _round_cost(self._total_cost)
-
-    def to_record(self) -> dict[str, Any]:
-        record = serialize_usage(self._total_usage)
-        record["cost"] = _round_cost(self._total_cost)
-        record["agents"] = []
-
-        agent_tokens = {aid: _resolve_total_tokens(u) for aid, u in self._agent_usage.items()}
-        total_tokens = sum(agent_tokens.values())
-        for agent_id in sorted(self._agent_usage):
-            usage = self._agent_usage[agent_id]
-            metadata = self._agent_metadata.get(agent_id, {})
-            agent_cost = (
-                self._total_cost * (agent_tokens[agent_id] / total_tokens) if total_tokens else 0.0
-            )
-
-            agent_record = serialize_usage(usage)
-            agent_record.update(
-                {
-                    "agent_id": agent_id,
-                    "agent_name": metadata.get("agent_name") or agent_id,
-                    "model": metadata.get("model"),
-                    "cost": _round_cost(agent_cost),
-                }
-            )
-            record["agents"].append(agent_record)
-
-        return record
-
-    def hydrate(self, raw_usage: Any) -> None:
-        self._total_usage = Usage()
-        self._agent_usage.clear()
-        self._agent_metadata.clear()
-        self._total_cost = 0.0
-
-        if not isinstance(raw_usage, dict):
-            return
-
-        try:
-            self._total_usage = deserialize_usage(raw_usage)
-        except Exception:
-            logger.exception("Failed to hydrate aggregate llm_usage from run.json")
-            self._total_usage = Usage()
-
-        self._total_cost = _float_or_zero(raw_usage.get("cost"))
-
-        for raw_agent in raw_usage.get("agents") or []:
-            if not isinstance(raw_agent, dict):
-                continue
-            agent_id = str(raw_agent.get("agent_id") or "").strip()
-            if not agent_id:
-                continue
-            try:
-                self._agent_usage[agent_id] = deserialize_usage(raw_agent)
-            except Exception:
-                logger.exception("Failed to hydrate llm_usage for agent %s", agent_id)
-                self._agent_usage[agent_id] = Usage()
-
-            metadata: dict[str, str] = {}
-            agent_name = raw_agent.get("agent_name")
-            model = raw_agent.get("model")
-            if isinstance(agent_name, str) and agent_name:
-                metadata["agent_name"] = agent_name
-            if isinstance(model, str) and model:
-                metadata["model"] = model
-            self._agent_metadata[agent_id] = metadata
-
-
-def _resolve_total_tokens(usage: Usage) -> int:
-    total = max(0, int(usage.total_tokens or 0))
-    if total > 0:
-        return total
-    prompt = _int_or_zero(getattr(usage, "input_tokens", 0))
-    completion = _int_or_zero(getattr(usage, "output_tokens", 0))
-    return prompt + completion
-
-
-def _is_litellm_routed(model: str | None) -> bool:
-    if not model:
-        return False
-    name = model.strip().lower()
-    if "/" not in name:
-        return False
-    return not name.startswith("openai/")
-
-
-def _usage_has_activity(usage: Usage) -> bool:
-    return bool(
-        usage.requests
-        or usage.input_tokens
-        or usage.output_tokens
-        or usage.total_tokens
-        or usage.request_usage_entries
-    )
-
-
-def _estimate_litellm_cost(usage: Usage, model: str | None) -> float | None:
-    litellm_model = _litellm_model_name(model)
-    if not litellm_model:
-        return None
-
-    entries = list(usage.request_usage_entries)
-    if not entries:
-        return _estimate_litellm_entry_cost(usage, litellm_model)
-
-    total = 0.0
-    estimated_any = False
-    for entry in entries:
-        cost = _estimate_litellm_entry_cost(entry, litellm_model)
-        if cost is None:
-            continue
-        total += cost
-        estimated_any = True
-
-    return total if estimated_any else None
-
-
-def _estimate_litellm_entry_cost(entry: Any, model: str) -> float | None:
-    prompt_tokens = _int_or_zero(getattr(entry, "input_tokens", 0))
-    completion_tokens = _int_or_zero(getattr(entry, "output_tokens", 0))
-    total_tokens = _int_or_zero(getattr(entry, "total_tokens", 0))
-    if total_tokens <= 0:
-        total_tokens = prompt_tokens + completion_tokens
-    if total_tokens <= 0:
-        return None
-
-    usage_payload: dict[str, Any] = {
-        "prompt_tokens": prompt_tokens,
-        "completion_tokens": completion_tokens,
-        "total_tokens": total_tokens,
-    }
-    prompt_details = _details_to_dict(getattr(entry, "input_tokens_details", None))
-    completion_details = _details_to_dict(getattr(entry, "output_tokens_details", None))
-    if prompt_details:
-        usage_payload["prompt_tokens_details"] = prompt_details
-    if completion_details:
-        usage_payload["completion_tokens_details"] = completion_details
-
-    from litellm import completion_cost
-
-    candidates = [model]
-    if "/" in model:
-        candidates.append(model.split("/", 1)[-1])
-
-    cost: Any = None
-    for candidate in candidates:
-        try:
-            cost = completion_cost(
-                completion_response={"model": candidate, "usage": usage_payload},
-                model=model,
-            )
-            break
-        except Exception:  # nosec B112  # noqa: BLE001, S112
-            continue
-
-    if cost is None:
-        logger.debug("LiteLLM cost estimate unavailable for model %s", model)
-        return None
-
-    return cost if isinstance(cost, int | float) and cost >= 0 else None
-
-
-def _litellm_model_name(model: str | None) -> str | None:
-    if not model:
-        return None
-    normalized = model.strip()
-    for prefix in ("litellm/", "any-llm/", "openai/"):
-        if normalized.startswith(prefix):
-            normalized = normalized.removeprefix(prefix)
-            break
-    return normalized or None
-
-
-def _details_to_dict(details: Any) -> dict[str, Any]:
-    if details is None:
-        return {}
-    if isinstance(details, list):
-        for item in details:
-            result = _details_to_dict(item)
-            if result:
-                return result
-        return {}
-    if hasattr(details, "model_dump"):
-        return _details_to_dict(details.model_dump())
-    if not isinstance(details, dict):
-        return {}
-    return {str(k): v for k, v in details.items() if v is not None}
-
-
-def _int_or_zero(value: Any) -> int:
-    try:
-        return max(0, int(value or 0))
-    except (TypeError, ValueError):
-        return 0
-
-
-def _float_or_zero(value: Any) -> float:
-    try:
-        result = float(value or 0.0)
-    except (TypeError, ValueError):
-        return 0.0
-    return result if result >= 0 else 0.0
-
-
-def _round_cost(cost: float) -> float:
-    return round(max(0.0, cost), 10)

strix/report/writer.py

@@ -1,197 +0,0 @@
-"""Artifact writers for Strix scan reports."""
-
-from __future__ import annotations
-
-import csv
-import io
-import json
-import logging
-import tempfile
-from datetime import UTC, datetime
-from pathlib import Path
-from typing import Any
-
-from strix.core.paths import run_record_path
-
-
-logger = logging.getLogger(__name__)
-
-_SEVERITY_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3, "info": 4}
-
-
-def read_run_record(run_dir: Path) -> dict[str, Any]:
-    path = run_record_path(run_dir)
-    if not path.exists():
-        return {}
-    try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError) as exc:
-        raise RuntimeError(f"run.json at {path} is unreadable: {exc}") from exc
-    if not isinstance(data, dict):
-        raise TypeError(f"run.json at {path} is not an object")
-    return data
-
-
-def write_run_record(run_dir: Path, run_record: dict[str, Any]) -> None:
-    _atomic_write_text(
-        run_record_path(run_dir),
-        json.dumps(run_record, ensure_ascii=False, indent=2, default=str),
-    )
-
-
-def write_executive_report(run_dir: Path, final_scan_result: str) -> 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"{final_scan_result}\n")
-    logger.info("Saved final penetration test report to: %s", path)
-
-
-def write_vulnerabilities(
-    run_dir: Path,
-    vulnerability_reports: list[dict[str, Any]],
-    saved_vuln_ids: set[str],
-) -> int:
-    vuln_dir = run_dir / "vulnerabilities"
-    vuln_dir.mkdir(exist_ok=True)
-
-    new_reports = [r for r in vulnerability_reports if r["id"] not in saved_vuln_ids]
-
-    for report in new_reports:
-        _atomic_write_text(
-            vuln_dir / f"{report['id']}.md",
-            render_vulnerability_md(report),
-        )
-        saved_vuln_ids.add(report["id"])
-
-    sorted_reports = sorted(
-        vulnerability_reports,
-        key=lambda r: (_SEVERITY_ORDER.get(r["severity"], 5), r["timestamp"]),
-    )
-    csv_path = run_dir / "vulnerabilities.csv"
-    csv_buf = io.StringIO()
-    fieldnames = ["id", "title", "severity", "timestamp", "file"]
-    csv_writer = csv.DictWriter(csv_buf, fieldnames=fieldnames, lineterminator="\r\n")
-    csv_writer.writeheader()
-    for report in sorted_reports:
-        csv_writer.writerow(
-            {
-                "id": report["id"],
-                "title": report["title"],
-                "severity": report["severity"].upper(),
-                "timestamp": report["timestamp"],
-                "file": f"vulnerabilities/{report['id']}.md",
-            },
-        )
-    _atomic_write_text(csv_path, csv_buf.getvalue())
-
-    _atomic_write_text(
-        run_dir / "vulnerabilities.json",
-        json.dumps(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)
-    return len(new_reports)
-
-
-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:  # noqa: PLR0912, PLR0915
-    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"):
-                    lines.extend(f"- {ln}" for ln in str(loc["fix_before"]).splitlines())
-                if loc.get("fix_after"):
-                    lines.extend(f"+ {ln}" for ln in str(loc["fix_after"]).splitlines())
-                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)

strix/runtime/__init__.py

@@ -1 +1,43 @@
-"""Pluggable sandbox lifecycle on top of the Agents SDK."""
+from strix.config import Config
+
+from .runtime import AbstractRuntime
+
+
+class SandboxInitializationError(Exception):
+    """Raised when sandbox initialization fails (e.g., Docker issues)."""
+
+    def __init__(self, message: str, details: str | None = None):
+        super().__init__(message)
+        self.message = message
+        self.details = details
+
+
+_global_runtime: AbstractRuntime | None = None
+
+
+def get_runtime() -> AbstractRuntime:
+    global _global_runtime  # noqa: PLW0603
+
+    runtime_backend = Config.get("strix_runtime_backend")
+
+    if runtime_backend == "docker":
+        from .docker_runtime import DockerRuntime
+
+        if _global_runtime is None:
+            _global_runtime = DockerRuntime()
+        return _global_runtime
+
+    raise ValueError(
+        f"Unsupported runtime backend: {runtime_backend}. Only 'docker' is supported for now."
+    )
+
+
+def cleanup_runtime() -> None:
+    global _global_runtime  # noqa: PLW0603
+
+    if _global_runtime is not None:
+        _global_runtime.cleanup()
+        _global_runtime = None
+
+
+__all__ = ["AbstractRuntime", "SandboxInitializationError", "cleanup_runtime", "get_runtime"]

strix/runtime/backends.py

@@ -1,93 +0,0 @@
-"""Sandbox backend registry — selected via STRIX_RUNTIME_BACKEND (default: docker)."""
-
-from __future__ import annotations
-
-import logging
-from collections.abc import Awaitable, Callable
-from typing import TYPE_CHECKING, Any
-
-
-if TYPE_CHECKING:
-    from agents.sandbox.manifest import Manifest
-
-
-logger = logging.getLogger(__name__)
-
-
-SandboxBackend = Callable[..., Awaitable[tuple[Any, Any]]]
-
-
-async def _docker_backend(
-    *,
-    image: str,
-    manifest: Manifest,
-    exposed_ports: tuple[int, ...],
-    bind_mounts: list[dict[str, Any]] | None = None,
-) -> tuple[Any, Any]:
-    """Bring up a session backed by the local Docker daemon.
-
-    Uses :class:`StrixDockerSandboxClient` to inject NET_ADMIN /
-    NET_RAW caps + ``host.docker.internal`` host-gateway. Imports
-    ``docker`` lazily so deployments that target a non-Docker
-    backend don't need the docker-py library installed.
-
-    ``session.start()`` is what materializes the manifest entries
-    (LocalDir copies and manifest-declared volume/FUSE mounts) into the
-    running container — the SDK's ``client.create()`` only builds the inner
-    session object without applying the manifest. ``async with session:``
-    would call it too, but Strix manages session lifetime explicitly via
-    ``client.delete()`` so we trigger ``start()`` ourselves.
-
-    ``bind_mounts`` are host directories (e.g. large repos passed via
-    ``--mount``) bind-mounted read-only; unlike manifest entries they are
-    applied by Docker at container-create time, not by ``start()``.
-    """
-    import docker
-    from agents.sandbox.sandboxes.docker import DockerSandboxClientOptions
-
-    from strix.runtime.docker_client import StrixDockerSandboxClient
-
-    client = StrixDockerSandboxClient(docker.from_env())
-    client.strix_bind_mounts = bind_mounts or []
-    options = DockerSandboxClientOptions(image=image, exposed_ports=exposed_ports)
-    session = await client.create(options=options, manifest=manifest)
-    await session.start()
-    return client, session
-
-
-_BACKENDS: dict[str, SandboxBackend] = {
-    "docker": _docker_backend,
-}
-
-
-def get_backend(name: str) -> SandboxBackend:
-    """Return the backend factory for ``name`` or raise.
-
-    Args:
-        name: Backend identifier (e.g. ``"docker"``). Match is exact;
-            no fallback. Unknown values raise so config typos surface
-            immediately instead of silently picking a default.
-    """
-    backend = _BACKENDS.get(name)
-    if backend is None:
-        supported = ", ".join(sorted(_BACKENDS))
-        raise ValueError(
-            f"Unknown STRIX_RUNTIME_BACKEND: {name!r} (supported: {supported})",
-        )
-    logger.debug("Selected sandbox backend: %s", name)
-    return backend
-
-
-def register_backend(name: str, backend: SandboxBackend) -> None:
-    """Register a custom backend under ``name``.
-
-    Intended for downstream users who ship their own runtime — register
-    before any ``session_manager.create_or_reuse`` call. Re-registering
-    an existing name overwrites the prior entry.
-    """
-    _BACKENDS[name] = backend
-    logger.info("Registered sandbox backend: %s", name)
-
-
-def supported_backends() -> list[str]:
-    return sorted(_BACKENDS)

strix/runtime/caido_bootstrap.py

@@ -1,101 +0,0 @@
-"""Caido client bootstrap.
-
-The Caido CLI runs as an in-container sidecar listening on
-``127.0.0.1:48080`` *inside* the sandbox. We grab a guest token by
-``session.exec()``-ing curl from inside the container, then construct
-a host-side :class:`caido_sdk_client.Client` against the runtime's
-exposed-port URL for all subsequent SDK calls.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-from typing import TYPE_CHECKING
-
-from caido_sdk_client import Client, TokenAuthOptions
-from caido_sdk_client.types import CreateProjectOptions
-
-
-if TYPE_CHECKING:
-    from agents.sandbox.session import BaseSandboxSession
-
-
-logger = logging.getLogger(__name__)
-
-
-_LOGIN_AS_GUEST_BODY = (
-    '{"query":"mutation LoginAsGuest { loginAsGuest { token { accessToken } } }"}'
-)
-
-
-async def _login_as_guest(
-    session: BaseSandboxSession,
-    *,
-    container_url: str,
-    attempts: int = 10,
-) -> str:
-    """``session.exec`` curl to fetch a guest token; retry until ready.
-
-    Caido's GraphQL listener may not be up the instant the container
-    starts. The retry loop also doubles as the Caido readiness probe —
-    no separate TCP healthcheck needed.
-    """
-    last_err: str | None = None
-    for i in range(1, attempts + 1):
-        result = await session.exec(
-            "curl",
-            "-fsS",
-            "-X",
-            "POST",
-            "-H",
-            "Content-Type: application/json",
-            "-d",
-            _LOGIN_AS_GUEST_BODY,
-            f"{container_url}/graphql",
-            timeout=15,
-        )
-        if result.ok():
-            try:
-                payload = json.loads(result.stdout)
-                token = (
-                    payload.get("data", {})
-                    .get("loginAsGuest", {})
-                    .get("token", {})
-                    .get("accessToken")
-                )
-                if token:
-                    return str(token)
-                last_err = f"loginAsGuest returned no token: {payload}"
-            except json.JSONDecodeError as exc:
-                last_err = f"unparseable response: {exc}: {result.stdout!r}"
-        else:
-            stderr = result.stderr.decode("utf-8", errors="replace")[:200]
-            last_err = f"curl exit {result.exit_code}: {stderr}"
-        logger.debug("loginAsGuest attempt %d/%d failed: %s", i, attempts, last_err)
-        await asyncio.sleep(min(2.0 * i, 8.0))
-
-    raise RuntimeError(f"loginAsGuest failed after {attempts} attempts: {last_err}")
-
-
-async def bootstrap_caido(
-    session: BaseSandboxSession,
-    *,
-    host_url: str,
-    container_url: str,
-) -> Client:
-    """Connect to the in-container Caido sidecar and select a fresh project."""
-    logger.info("Bootstrapping Caido client (host=%s, container=%s)", host_url, container_url)
-
-    access_token = await _login_as_guest(session, container_url=container_url)
-
-    client = Client(host_url, auth=TokenAuthOptions(token=access_token))
-    await client.connect()
-
-    project = await client.project.create(
-        CreateProjectOptions(name="sandbox", temporary=True),
-    )
-    await client.project.select(project.id)
-    logger.info("Caido project selected: %s", project.id)
-    return client

strix/runtime/docker_client.py

@@ -1,163 +0,0 @@
-"""StrixDockerSandboxClient — preserves the image's ENTRYPOINT and adds
-NET_ADMIN/NET_RAW capabilities + host-gateway.
-
-The SDK's ``DockerSandboxClient._create_container`` does not expose a hook for
-extending ``create_kwargs`` before ``containers.create`` is called. We subclass
-and reimplement the method body verbatim from the SDK source, with three
-deltas:
-
-1. Drop the SDK's ``entrypoint=["tail"]`` override; supply ``["tail", "-f",
-   "/dev/null"]`` as ``command`` instead. This lets our image's
-   ``docker-entrypoint.sh`` actually run — without it, ``caido-cli`` never
-   starts inside the container and ``bootstrap_caido`` retries against a
-   dead port.
-2. Append NET_ADMIN/NET_RAW to ``cap_add`` (required by ``nmap -sS`` and
-   other raw-socket tools).
-3. Add ``host.docker.internal`` → host-gateway to ``extra_hosts`` so the
-   agent can reach host-served apps.
-
-Pinned to ``openai-agents==0.14.6``. Bumping the SDK requires
-re-merging the parent body. Track upstream for an injection hook.
-"""
-
-from __future__ import annotations
-
-import contextlib
-import logging
-import uuid
-from typing import Any
-
-from agents.sandbox.manifest import Manifest
-from agents.sandbox.sandboxes.docker import (
-    DockerSandboxClient,
-    _build_docker_volume_mounts,
-    _docker_port_key,
-    _manifest_requires_fuse,
-    _manifest_requires_sys_admin,
-)
-from agents.sandbox.session.sandbox_session import SandboxSession
-from docker import errors as docker_errors  # type: ignore[import-untyped, unused-ignore]
-from docker.models.containers import Container  # type: ignore[import-untyped, unused-ignore]
-from docker.types import Mount as DockerSDKMount  # type: ignore[import-untyped, unused-ignore]
-from docker.utils import parse_repository_tag  # type: ignore[import-untyped, unused-ignore]
-from requests.exceptions import RequestException
-
-
-logger = logging.getLogger(__name__)
-
-
-class StrixDockerSandboxClient(DockerSandboxClient):
-    # Host directories to bind-mount into the container, set by the docker
-    # backend before ``create()``. Each item is ``{source, target, read_only}``.
-    strix_bind_mounts: list[dict[str, Any]] = []  # overridden per-instance in backends.py
-
-    async def _create_container(
-        self,
-        image: str,
-        *,
-        manifest: Manifest | None = None,
-        exposed_ports: tuple[int, ...] = (),
-        session_id: uuid.UUID | None = None,
-    ) -> Container:
-        # ----- BEGIN VERBATIM COPY of DockerSandboxClient._create_container -----
-        # SDK ref: src/agents/sandbox/sandboxes/docker.py:1434-1477 (v0.14.6).
-        if not self.image_exists(image):
-            repo, tag = parse_repository_tag(image)
-            self.docker_client.images.pull(repo, tag=tag or None, all_tags=False)
-
-        assert self.image_exists(image)
-        environment: dict[str, str] | None = None
-        if manifest:
-            environment = await manifest.environment.resolve()
-        # Strix delta from the SDK body: drop ``entrypoint`` override and
-        # supply ``tail -f /dev/null`` as ``command`` so the image's
-        # ENTRYPOINT (``docker-entrypoint.sh``) runs setup, then ``exec
-        # "$@"`` becomes ``exec tail -f /dev/null`` for the keep-alive.
-        # Without this, caido-cli + the in-container CA trust never get
-        # initialized.
-        create_kwargs: dict[str, Any] = {
-            "image": image,
-            "detach": True,
-            "command": ["tail", "-f", "/dev/null"],
-            "environment": environment,
-        }
-        if manifest is not None:
-            docker_mounts = _build_docker_volume_mounts(
-                manifest,
-                session_id=session_id,
-            )
-            if docker_mounts:
-                create_kwargs["mounts"] = docker_mounts
-            if _manifest_requires_fuse(manifest):
-                create_kwargs.update(
-                    devices=["/dev/fuse"],
-                    cap_add=["SYS_ADMIN"],
-                    security_opt=["apparmor:unconfined"],
-                )
-            elif _manifest_requires_sys_admin(manifest):
-                create_kwargs.update(
-                    cap_add=["SYS_ADMIN"],
-                    security_opt=["apparmor:unconfined"],
-                )
-        if exposed_ports:
-            create_kwargs["ports"] = {
-                _docker_port_key(port): ("127.0.0.1", None) for port in exposed_ports
-            }
-        # ----- END VERBATIM COPY -----
-
-        # Strix injections — append, don't overwrite, so FUSE/SYS_ADMIN survives.
-        cap_add = create_kwargs.setdefault("cap_add", [])
-        if not isinstance(cap_add, list):
-            cap_add = list(cap_add)
-            create_kwargs["cap_add"] = cap_add
-        for cap in ("NET_ADMIN", "NET_RAW"):
-            if cap not in cap_add:
-                cap_add.append(cap)
-
-        extra_hosts = create_kwargs.setdefault("extra_hosts", {})
-        extra_hosts["host.docker.internal"] = "host-gateway"
-
-        # Strix injection: host bind mounts (e.g. large repos passed via --mount)
-        # that bypass the SDK's file-by-file LocalDir copy.
-        bind_mounts = getattr(self, "strix_bind_mounts", ())
-        if bind_mounts:
-            mounts = create_kwargs.setdefault("mounts", [])
-            for spec in bind_mounts:
-                mounts.append(
-                    DockerSDKMount(
-                        target=spec["target"],
-                        source=spec["source"],
-                        type="bind",
-                        read_only=spec.get("read_only", True),
-                    )
-                )
-
-        logger.debug(
-            "Creating sandbox container: image=%s caps=%s exposed_ports=%s",
-            image,
-            cap_add,
-            list(exposed_ports),
-        )
-        container = self.docker_client.containers.create(**create_kwargs)
-        logger.info(
-            "Sandbox container created: id=%s image=%s",
-            container.short_id if hasattr(container, "short_id") else "?",
-            image,
-        )
-        return container
-
-    async def delete(self, session: SandboxSession) -> SandboxSession:
-        container_id = getattr(getattr(session._inner, "state", None), "container_id", None)
-        if container_id:
-            # Best-effort kill: NotFound/APIError cover a gone or unhappy
-            # container. RequestException covers a torn-down daemon socket —
-            # containers.get() -> inspect_container raises requests'
-            # ConnectionError, which is a sibling of docker.errors.APIError
-            # under requests.RequestException (not a subclass), so it escapes
-            # an APIError-only suppress and surfaces a full traceback even
-            # though this teardown is meant to be best-effort.
-            with contextlib.suppress(
-                docker_errors.NotFound, docker_errors.APIError, RequestException
-            ):
-                self.docker_client.containers.get(container_id).kill()
-        return await super().delete(session)

strix/runtime/docker_runtime.py

@@ -0,0 +1,352 @@
+import contextlib
+import os
+import secrets
+import socket
+import time
+from pathlib import Path
+from typing import cast
+
+import docker
+import httpx
+from docker.errors import DockerException, ImageNotFound, NotFound
+from docker.models.containers import Container
+from requests.exceptions import ConnectionError as RequestsConnectionError
+from requests.exceptions import Timeout as RequestsTimeout
+
+from strix.config import Config
+
+from . import SandboxInitializationError
+from .runtime import AbstractRuntime, SandboxInfo
+
+
+HOST_GATEWAY_HOSTNAME = "host.docker.internal"
+DOCKER_TIMEOUT = 60
+CONTAINER_TOOL_SERVER_PORT = 48081
+CONTAINER_CAIDO_PORT = 48080
+
+
+class DockerRuntime(AbstractRuntime):
+    def __init__(self) -> None:
+        try:
+            self.client = docker.from_env(timeout=DOCKER_TIMEOUT)
+        except (DockerException, RequestsConnectionError, RequestsTimeout) as e:
+            raise SandboxInitializationError(
+                "Docker is not available",
+                "Please ensure Docker Desktop is installed and running.",
+            ) from e
+
+        self._scan_container: Container | None = None
+        self._tool_server_port: int | None = None
+        self._tool_server_token: str | None = None
+        self._caido_port: int | None = None
+
+    def _find_available_port(self) -> int:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("", 0))
+            return cast("int", s.getsockname()[1])
+
+    def _get_scan_id(self, agent_id: str) -> str:
+        try:
+            from strix.telemetry.tracer import get_global_tracer
+
+            tracer = get_global_tracer()
+            if tracer and tracer.scan_config:
+                return str(tracer.scan_config.get("scan_id", "default-scan"))
+        except (ImportError, AttributeError):
+            pass
+        return f"scan-{agent_id.split('-')[0]}"
+
+    def _verify_image_available(self, image_name: str, max_retries: int = 3) -> None:
+        for attempt in range(max_retries):
+            try:
+                image = self.client.images.get(image_name)
+                if not image.id or not image.attrs:
+                    raise ImageNotFound(f"Image {image_name} metadata incomplete")  # noqa: TRY301
+            except (ImageNotFound, DockerException):
+                if attempt == max_retries - 1:
+                    raise
+                time.sleep(2**attempt)
+            else:
+                return
+
+    def _recover_container_state(self, container: Container) -> None:
+        for env_var in container.attrs["Config"]["Env"]:
+            if env_var.startswith("TOOL_SERVER_TOKEN="):
+                self._tool_server_token = env_var.split("=", 1)[1]
+                break
+
+        port_bindings = container.attrs.get("NetworkSettings", {}).get("Ports", {})
+        port_key = f"{CONTAINER_TOOL_SERVER_PORT}/tcp"
+        if port_bindings.get(port_key):
+            self._tool_server_port = int(port_bindings[port_key][0]["HostPort"])
+
+        caido_port_key = f"{CONTAINER_CAIDO_PORT}/tcp"
+        if port_bindings.get(caido_port_key):
+            self._caido_port = int(port_bindings[caido_port_key][0]["HostPort"])
+
+    def _wait_for_tool_server(self, max_retries: int = 30, timeout: int = 5) -> None:
+        host = self._resolve_docker_host()
+        health_url = f"http://{host}:{self._tool_server_port}/health"
+
+        time.sleep(5)
+
+        for attempt in range(max_retries):
+            try:
+                with httpx.Client(trust_env=False, timeout=timeout) as client:
+                    response = client.get(health_url)
+                    if response.status_code == 200:
+                        data = response.json()
+                        if data.get("status") == "healthy":
+                            return
+            except (httpx.ConnectError, httpx.TimeoutException, httpx.RequestError):
+                pass
+
+            time.sleep(min(2**attempt * 0.5, 5))
+
+        raise SandboxInitializationError(
+            "Tool server failed to start",
+            "Container initialization timed out. Please try again.",
+        )
+
+    def _create_container(self, scan_id: str, max_retries: int = 2) -> Container:
+        container_name = f"strix-scan-{scan_id}"
+        image_name = Config.get("strix_image")
+        if not image_name:
+            raise ValueError("STRIX_IMAGE must be configured")
+
+        self._verify_image_available(image_name)
+
+        last_error: Exception | None = None
+        for attempt in range(max_retries + 1):
+            try:
+                with contextlib.suppress(NotFound):
+                    existing = self.client.containers.get(container_name)
+                    with contextlib.suppress(Exception):
+                        existing.stop(timeout=5)
+                    existing.remove(force=True)
+                    time.sleep(1)
+
+                self._tool_server_port = self._find_available_port()
+                self._caido_port = self._find_available_port()
+                self._tool_server_token = secrets.token_urlsafe(32)
+                execution_timeout = Config.get("strix_sandbox_execution_timeout") or "120"
+
+                container = self.client.containers.run(
+                    image_name,
+                    command="sleep infinity",
+                    detach=True,
+                    name=container_name,
+                    hostname=container_name,
+                    ports={
+                        f"{CONTAINER_TOOL_SERVER_PORT}/tcp": self._tool_server_port,
+                        f"{CONTAINER_CAIDO_PORT}/tcp": self._caido_port,
+                    },
+                    cap_add=["NET_ADMIN", "NET_RAW"],
+                    labels={"strix-scan-id": scan_id},
+                    environment={
+                        "PYTHONUNBUFFERED": "1",
+                        "TOOL_SERVER_PORT": str(CONTAINER_TOOL_SERVER_PORT),
+                        "TOOL_SERVER_TOKEN": self._tool_server_token,
+                        "STRIX_SANDBOX_EXECUTION_TIMEOUT": str(execution_timeout),
+                        "HOST_GATEWAY": HOST_GATEWAY_HOSTNAME,
+                    },
+                    extra_hosts={HOST_GATEWAY_HOSTNAME: "host-gateway"},
+                    tty=True,
+                )
+
+                self._scan_container = container
+                self._wait_for_tool_server()
+
+            except (DockerException, RequestsConnectionError, RequestsTimeout) as e:
+                last_error = e
+                if attempt < max_retries:
+                    self._tool_server_port = None
+                    self._tool_server_token = None
+                    self._caido_port = None
+                    time.sleep(2**attempt)
+            else:
+                return container
+
+        raise SandboxInitializationError(
+            "Failed to create container",
+            f"Container creation failed after {max_retries + 1} attempts: {last_error}",
+        ) from last_error
+
+    def _get_or_create_container(self, scan_id: str) -> Container:
+        container_name = f"strix-scan-{scan_id}"
+
+        if self._scan_container:
+            try:
+                self._scan_container.reload()
+                if self._scan_container.status == "running":
+                    return self._scan_container
+            except NotFound:
+                self._scan_container = None
+                self._tool_server_port = None
+                self._tool_server_token = None
+                self._caido_port = None
+
+        try:
+            container = self.client.containers.get(container_name)
+            container.reload()
+
+            if container.status != "running":
+                container.start()
+                time.sleep(2)
+
+            self._scan_container = container
+            self._recover_container_state(container)
+        except NotFound:
+            pass
+        else:
+            return container
+
+        try:
+            containers = self.client.containers.list(
+                all=True, filters={"label": f"strix-scan-id={scan_id}"}
+            )
+            if containers:
+                container = containers[0]
+                if container.status != "running":
+                    container.start()
+                    time.sleep(2)
+
+                self._scan_container = container
+                self._recover_container_state(container)
+                return container
+        except DockerException:
+            pass
+
+        return self._create_container(scan_id)
+
+    def _copy_local_directory_to_container(
+        self, container: Container, local_path: str, target_name: str | None = None
+    ) -> None:
+        import tarfile
+        from io import BytesIO
+
+        try:
+            local_path_obj = Path(local_path).resolve()
+            if not local_path_obj.exists() or not local_path_obj.is_dir():
+                return
+
+            tar_buffer = BytesIO()
+            with tarfile.open(fileobj=tar_buffer, mode="w") as tar:
+                for item in local_path_obj.rglob("*"):
+                    if item.is_file():
+                        rel_path = item.relative_to(local_path_obj)
+                        arcname = Path(target_name) / rel_path if target_name else rel_path
+                        tar.add(item, arcname=arcname)
+
+            tar_buffer.seek(0)
+            container.put_archive("/workspace", tar_buffer.getvalue())
+            container.exec_run(
+                "chown -R pentester:pentester /workspace && chmod -R 755 /workspace",
+                user="root",
+            )
+        except (OSError, DockerException):
+            pass
+
+    async def create_sandbox(
+        self,
+        agent_id: str,
+        existing_token: str | None = None,
+        local_sources: list[dict[str, str]] | None = None,
+    ) -> SandboxInfo:
+        scan_id = self._get_scan_id(agent_id)
+        container = self._get_or_create_container(scan_id)
+
+        source_copied_key = f"_source_copied_{scan_id}"
+        if local_sources and not hasattr(self, source_copied_key):
+            for index, source in enumerate(local_sources, start=1):
+                source_path = source.get("source_path")
+                if not source_path:
+                    continue
+                target_name = (
+                    source.get("workspace_subdir") or Path(source_path).name or f"target_{index}"
+                )
+                self._copy_local_directory_to_container(container, source_path, target_name)
+            setattr(self, source_copied_key, True)
+
+        if container.id is None:
+            raise RuntimeError("Docker container ID is unexpectedly None")
+
+        token = existing_token or self._tool_server_token
+        if self._tool_server_port is None or self._caido_port is None or token is None:
+            raise RuntimeError("Tool server not initialized")
+
+        host = self._resolve_docker_host()
+        api_url = f"http://{host}:{self._tool_server_port}"
+
+        await self._register_agent(api_url, agent_id, token)
+
+        return {
+            "workspace_id": container.id,
+            "api_url": api_url,
+            "auth_token": token,
+            "tool_server_port": self._tool_server_port,
+            "caido_port": self._caido_port,
+            "agent_id": agent_id,
+        }
+
+    async def _register_agent(self, api_url: str, agent_id: str, token: str) -> None:
+        try:
+            async with httpx.AsyncClient(trust_env=False) as client:
+                response = await client.post(
+                    f"{api_url}/register_agent",
+                    params={"agent_id": agent_id},
+                    headers={"Authorization": f"Bearer {token}"},
+                    timeout=30,
+                )
+                response.raise_for_status()
+        except httpx.RequestError:
+            pass
+
+    async def get_sandbox_url(self, container_id: str, port: int) -> str:
+        try:
+            self.client.containers.get(container_id)
+            return f"http://{self._resolve_docker_host()}:{port}"
+        except NotFound:
+            raise ValueError(f"Container {container_id} not found.") from None
+
+    def _resolve_docker_host(self) -> str:
+        docker_host = os.getenv("DOCKER_HOST", "")
+        if docker_host:
+            from urllib.parse import urlparse
+
+            parsed = urlparse(docker_host)
+            if parsed.scheme in ("tcp", "http", "https") and parsed.hostname:
+                return parsed.hostname
+        return "127.0.0.1"
+
+    async def destroy_sandbox(self, container_id: str) -> None:
+        try:
+            container = self.client.containers.get(container_id)
+            container.stop()
+            container.remove()
+            self._scan_container = None
+            self._tool_server_port = None
+            self._tool_server_token = None
+            self._caido_port = None
+        except (NotFound, DockerException):
+            pass
+
+    def cleanup(self) -> None:
+        if self._scan_container is not None:
+            container_name = self._scan_container.name
+            self._scan_container = None
+            self._tool_server_port = None
+            self._tool_server_token = None
+            self._caido_port = None
+
+            if container_name is None:
+                return
+
+            import subprocess
+
+            subprocess.Popen(  # noqa: S603
+                ["docker", "rm", "-f", container_name],  # noqa: S607
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )

strix/runtime/runtime.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+from typing import TypedDict
+
+
+class SandboxInfo(TypedDict):
+    workspace_id: str
+    api_url: str
+    auth_token: str | None
+    tool_server_port: int
+    caido_port: int
+    agent_id: str
+
+
+class AbstractRuntime(ABC):
+    @abstractmethod
+    async def create_sandbox(
+        self,
+        agent_id: str,
+        existing_token: str | None = None,
+        local_sources: list[dict[str, str]] | None = None,
+    ) -> SandboxInfo:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_sandbox_url(self, container_id: str, port: int) -> str:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def destroy_sandbox(self, container_id: str) -> None:
+        raise NotImplementedError
+
+    def cleanup(self) -> None:
+        raise NotImplementedError

strix/runtime/session_manager.py

@@ -1,164 +0,0 @@
-"""Per-scan sandbox session lifecycle."""
-
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-from typing import Any
-
-from agents.sandbox.entries import BaseEntry, LocalDir
-from agents.sandbox.manifest import Environment, Manifest
-
-from strix.config import load_settings
-from strix.runtime.backends import get_backend
-from strix.runtime.caido_bootstrap import bootstrap_caido
-
-
-logger = logging.getLogger(__name__)
-
-
-# In-container Caido sidecar port (matches the image's caido-cli bind).
-_CONTAINER_CAIDO_PORT = 48080
-
-
-_SESSION_CACHE: dict[str, dict[str, Any]] = {}
-
-# Manifest root inside the container; entry keys hang off this path.
-_WORKSPACE_ROOT = "/workspace"
-
-
-def build_session_entries(
-    local_sources: list[dict[str, Any]],
-) -> tuple[dict[str | Path, BaseEntry], list[dict[str, Any]]]:
-    """Split local sources into copied manifest entries and host bind mounts.
-
-    Sources flagged ``mount`` are bind-mounted read-only at
-    ``/workspace/<workspace_subdir>`` (not added to the manifest, so the SDK
-    does not stream them in file-by-file). Every other source becomes a
-    ``LocalDir`` entry copied into the container as before.
-    """
-    entries: dict[str | Path, BaseEntry] = {}
-    bind_mounts: list[dict[str, Any]] = []
-    for src in local_sources:
-        ws_subdir = src.get("workspace_subdir") or ""
-        host_path = src.get("source_path") or ""
-        if not ws_subdir or not host_path:
-            continue
-        resolved = Path(host_path).expanduser().resolve()
-        if src.get("mount"):
-            bind_mounts.append(
-                {
-                    "source": str(resolved),
-                    "target": f"{_WORKSPACE_ROOT}/{ws_subdir}",
-                    "read_only": True,
-                }
-            )
-        else:
-            entries[ws_subdir] = LocalDir(src=resolved)
-    return entries, bind_mounts
-
-
-async def create_or_reuse(
-    scan_id: str,
-    *,
-    image: str,
-    local_sources: list[dict[str, Any]],
-) -> dict[str, Any]:
-    """Return the existing session bundle for ``scan_id`` or create a new one.
-
-    Each ``local_sources`` entry exposes its host ``source_path`` at
-    ``/workspace/<workspace_subdir>`` inside the container — copied in, or
-    bind-mounted read-only when the entry is flagged ``mount``.
-    """
-    cached = _SESSION_CACHE.get(scan_id)
-    if cached is not None:
-        logger.info("Reusing existing sandbox session for scan %s", scan_id)
-        return cached
-
-    entries, bind_mounts = build_session_entries(local_sources)
-
-    # Caido runs as an in-container sidecar; HTTP(S) traffic from any
-    # process started via ``session.exec`` (the SDK's Shell tool, etc.)
-    # picks up these env vars automatically. ``NO_PROXY`` keeps the
-    # agent-browser CDP daemon's localhost traffic from looping back
-    # through Caido.
-    container_caido_url = f"http://127.0.0.1:{_CONTAINER_CAIDO_PORT}"
-    manifest = Manifest(
-        entries=entries,
-        environment=Environment(
-            value={
-                "PYTHONUNBUFFERED": "1",
-                "HOST_GATEWAY": "host.docker.internal",
-                "http_proxy": container_caido_url,
-                "https_proxy": container_caido_url,
-                "ALL_PROXY": container_caido_url,
-                "NO_PROXY": "localhost,127.0.0.1",
-            },
-        ),
-    )
-
-    backend_name = load_settings().runtime.backend
-    backend = get_backend(backend_name)
-
-    logger.info(
-        "Creating sandbox session for scan %s (backend=%s, image=%s)",
-        scan_id,
-        backend_name,
-        image,
-    )
-    client, session = await backend(
-        image=image,
-        manifest=manifest,
-        exposed_ports=(_CONTAINER_CAIDO_PORT,),
-        bind_mounts=bind_mounts,
-    )
-
-    caido_endpoint = await session.resolve_exposed_port(_CONTAINER_CAIDO_PORT)
-    scheme = "https" if caido_endpoint.tls else "http"
-    host_caido_url = f"{scheme}://{caido_endpoint.host}:{caido_endpoint.port}"
-    logger.debug("Caido host endpoint resolved: %s", host_caido_url)
-
-    caido_client = await bootstrap_caido(
-        session,
-        host_url=host_caido_url,
-        container_url=container_caido_url,
-    )
-
-    bundle = {
-        "client": client,
-        "session": session,
-        "caido_client": caido_client,
-    }
-    _SESSION_CACHE[scan_id] = bundle
-    logger.info("Sandbox session for scan %s ready and cached", scan_id)
-    return bundle
-
-
-async def cleanup(scan_id: str) -> None:
-    """Tear down ``scan_id``'s container and drop its cache entry.
-
-    Best-effort: any error during ``client.delete`` is logged and
-    swallowed. We never want a cleanup failure to prevent the next
-    scan from starting; the worst case is a stranded container that
-    Docker's normal reaping will catch on next ``docker prune``.
-    """
-    bundle = _SESSION_CACHE.pop(scan_id, None)
-    if bundle is None:
-        logger.debug("cleanup(%s): no cached session", scan_id)
-        return
-
-    caido_client = bundle.get("caido_client")
-    if caido_client is not None:
-        try:
-            await caido_client.aclose()
-        except Exception:  # noqa: BLE001
-            logger.debug("cleanup(%s): caido_client.aclose() raised", scan_id, exc_info=True)
-
-    try:
-        await bundle["client"].delete(bundle["session"])
-        logger.info("Cleaned up sandbox session for scan %s", scan_id)
-    except Exception:
-        logger.exception(
-            "cleanup(%s): client.delete raised; container may need manual reaping",
-            scan_id,
-        )