whitebox follow up: better wiki

# Conflicts:
#	strix/agents/StrixAgent/strix_agent.py
#	strix/agents/StrixAgent/system_prompt.jinja

.github/workflows/build-release.yml

@@ -6,9 +6,6 @@ on:
       - 'v*'
   workflow_dispatch:
 
-permissions:
-  contents: read
-
 jobs:
   build:
     strategy:
@@ -17,70 +14,31 @@ jobs:
         include:
           - os: macos-latest
             target: macos-arm64
-            wheel-platform: macosx_11_0_arm64
           - os: macos-15-intel
             target: macos-x86_64
-            wheel-platform: macosx_11_0_x86_64
-          - os: ubuntu-22.04
+          - os: ubuntu-latest
             target: linux-x86_64
-            wheel-platform: manylinux_2_17_x86_64
-          - os: ubuntu-22.04-arm
-            target: linux-arm64
-            wheel-platform: manylinux_2_17_aarch64
           - os: windows-latest
             target: windows-x86_64
-            wheel-platform: win_amd64
 
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262  # v4.4.0
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@v4
 
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065  # v5.6.0
+      - uses: actions/setup-python@v5
         with:
           python-version: '3.12'
 
-      - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86  # v5.4.2
-
-      - uses: actions/setup-go@44694675825211faa026b3c33043df3e48a5fa00  # v6.0.0
-        with:
-          go-version: '1.24.x'
-          check-latest: true
-          cache-dependency-path: strix/interface/tui/go.sum
+      - uses: snok/install-poetry@v1
 
       - name: Build
         shell: bash
-        env:
-          STRIX_WHEEL_PLATFORM_TAG: ${{ matrix.wheel-platform }}
         run: |
-          uv sync --frozen
-          uv build --wheel
-          uv run python -c 'import glob, os, sys, zipfile; wheels = glob.glob("dist/*.whl"); assert len(wheels) == 1, wheels; archive = zipfile.ZipFile(wheels[0]); tui = "strix/bin/strix-tui.exe" if sys.platform == "win32" else "strix/bin/strix-tui"; assert tui in archive.namelist(); metadata = archive.read(next(name for name in archive.namelist() if name.endswith(".dist-info/WHEEL"))).decode(); assert "Root-Is-Purelib: false" in metadata; assert "Tag: py3-none-" + os.environ["STRIX_WHEEL_PLATFORM_TAG"] in metadata'
+          poetry install --with dev
+          poetry run pyinstaller strix.spec --noconfirm
 
-          uv run pyinstaller strix.spec --noconfirm
-
-          if [[ "${{ runner.os }}" == "Windows" ]]; then
-            PYI_BINARY="dist/strix.exe"
-            TUI_NAME="strix-tui.exe"
-            dist/strix.exe --version
-          else
-            PYI_BINARY="dist/strix"
-            TUI_NAME="strix-tui"
-            dist/strix --version
-          fi
-          uv run pyi-archive_viewer -l "$PYI_BINARY" | grep -E "strix[/\\]+bin[/\\]+$TUI_NAME" >/dev/null
-
-          if [[ "${{ matrix.target }}" == "linux-arm64" ]]; then
-            file dist/strix
-            file dist/strix | grep -q "ARM aarch64" || {
-              echo "::error::linux-arm64 artifact is not an ARM aarch64 binary"
-              exit 1
-            }
-          fi
-
-          VERSION=$(grep '^version' pyproject.toml | head -1 | sed 's/.*"\(.*\)"/\1/')
+          VERSION=$(poetry version -s)
           mkdir -p dist/release
 
           if [[ "${{ runner.os }}" == "Windows" ]]; then
@@ -92,13 +50,12 @@ jobs:
             tar -C dist/release -czvf "dist/release/strix-${VERSION}-${{ matrix.target }}.tar.gz" "strix-${VERSION}-${{ matrix.target }}"
           fi
 
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02  # v4.6.2
+      - uses: actions/upload-artifact@v4
         with:
           name: strix-${{ matrix.target }}
           path: |
             dist/release/*.tar.gz
             dist/release/*.zip
-            dist/*.whl
           if-no-files-found: error
 
   release:
@@ -108,14 +65,14 @@ jobs:
       contents: write
 
     steps:
-      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093  # v4.3.0
+      - uses: actions/download-artifact@v4
         with:
           path: release
           merge-multiple: true
 
       - name: Create Release
-        uses: softprops/action-gh-release@3bb12739c298aeb8a4eeaf626c5b8d85266b0e65  # v2.6.2
+        uses: softprops/action-gh-release@v2
         with:
           prerelease: ${{ !startsWith(github.ref, 'refs/tags/') }}
           generate_release_notes: true
-          files: release/**
+          files: release/*

.gitignore

@@ -1,25 +1,17 @@
-# Node / local-viewer SPA source (the built bundle in
-# strix/interface/viewer/static/ is committed and shipped; do not ignore it)
-node_modules/
-strix/interface/viewer/frontend/node_modules/
-strix/interface/viewer/frontend/.vite/
-
 # Python
 __pycache__/
 *.py[cod]
 *$py.class
 *.so
 .Python
-# Anchored to the repo root: these are Python build-artifact dir names, but
-# unanchored they also match nested source dirs (e.g. the viewer's src/lib).
-/build/
+build/
 develop-eggs/
 dist/
 downloads/
 eggs/
 .eggs/
-/lib/
-/lib64/
+lib/
+lib64/
 parts/
 sdist/
 var/
@@ -47,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
@@ -54,7 +58,7 @@ pip-delete-this-directory.txt
 .env.production.local
 
 # MongoDB
-/data/
+data/
 mongod.log
 *.mongodb
 *.mongorc.js
@@ -93,8 +97,3 @@ Thumbs.db
 schema.graphql
 
 .opencode/
-
-# Root-only local data and reference checkouts
-/.benchmarks/
-/references/
-/strix_runs_main/

.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,9 +19,6 @@ repos:
           types-python-dateutil,
           pydantic,
           fastapi,
-          pytest,
-          hatchling,
-          "openai-agents[litellm]>=0.19.0,<0.20",
         ]
         args: [--install-types, --non-interactive]
 
@@ -34,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
@@ -48,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]

AGENTS.md

@@ -1,49 +0,0 @@
-# Strix — Agent Guide
-
-Strix is an open-source autonomous AI pentesting tool. This file is for AI coding agents that want to **use** Strix (run security scans) or **contribute** to it.
-
-## Using Strix from an agent
-
-Install the agent skills for step-by-step workflows:
-
-```bash
-npx skills add usestrix/strix
-```
-
-- `penetration-testing-with-strix` — run a headless pentest against code, URLs, domains, or IPs and read results (covers both run modes below)
-- `managed-pentesting-with-strix` — drive the managed app.strix.ai platform via REST (no local Docker/LLM needed)
-- `fix-security-vulnerabilities-with-strix` — remediate findings and re-run Strix to verify
-- `ci-security-scanning-with-strix` — add PR scanning to CI/CD (self-hosted CLI or managed app)
-
-**Two ways to run, same engine — pick per situation:**
-
-- **Open-source CLI (self-hosted):** free, fully local, BYO LLM key, needs Docker. Best for local dev loops, air-gapped/offline, and full control.
-  ```bash
-  curl -sSL https://strix.ai/install | bash        # install
-  export STRIX_LLM="openai/gpt-5.4"                 # any LiteLLM model id
-  export LLM_API_KEY="<key>"
-  strix -n -t ./ --scan-mode quick --max-budget 10  # headless scan; always use -n
-  ```
-  - Requires Docker running. Scans take minutes (`quick`) to hours (`deep`) — run in the background.
-  - Exit codes (headless): `0` clean, `1` fatal error, `2` vulnerabilities found. A `0` only covers what was analyzed — check `run.json` (`status`, `llm_usage.cost` vs the budget) before calling a run clean.
-  - Artifacts in `strix_runs/<run-name>/`: `penetration_test_report.md`, `vulnerabilities/*.md`, `vulnerabilities.json`, `findings.sarif` (SARIF 2.1.0), `run.json`.
-
-- **Managed cloud (app.strix.ai):** no Docker, no LLM key, no local install; adds team dashboards, scheduling, PR reviews, and downloadable PDF/DOCX reports (Enterprise plan). Best in sandboxed/CI environments and for teams. Use it when local infra isn't available.
-  ```bash
-  # token from Settings → API Access; register the target as an asset, then:
-  curl -sS https://app.strix.ai/api/v1/scans -H "Authorization: Bearer $STRIX_API_TOKEN" \
-    -H "Content-Type: application/json" -d '{"engagement_type":"live_test","domain_ids":["<uuid>"]}'
-  ```
-  - API docs: https://docs.app.strix.ai (OpenAPI: https://docs.app.strix.ai/openapi.json).
-
-- CLI docs index for LLMs: https://docs.strix.ai/llms.txt (full: https://docs.strix.ai/llms-full.txt).
-- Only scan targets the user is authorized to test.
-
-## Contributing to this repo
-
-- Python 3.12+, managed with `uv`. Install dev deps: `make dev-install`.
-- Lint/format/type-check/security, all in one: `make check-all` (ruff, mypy, bandit).
-- Tests: `uv run pytest`.
-- Run from source: `uv run strix --target <target>`.
-- Layout: `strix/agents` (agent graph + prompts), `strix/tools` (proxy, browser, terminal, scanners), `strix/runtime` (Docker sandbox), `strix/report` (findings, SARIF), `strix/skills` (internal knowledge packs the pentest agents load — different from the consumer skills in `skills/`), `strix/interface` (CLI/TUI), `containers/` (sandbox image).
-- Pre-commit hooks: `make pre-commit` (or `uv run pre-commit install`).

CONTRIBUTING.md

@@ -7,9 +7,8 @@ Thank you for your interest in contributing to Strix! This guide will help you g
 ### Prerequisites
 
 - Python 3.12+
-- Latest Go 1.24.x patch (only for Bubble Tea TUI development and release artifacts)
 - Docker (running)
-- [uv](https://docs.astral.sh/uv/) (for dependency management)
+- Poetry (for dependency management)
 - Git
 
 ### Local Development
@@ -25,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**
@@ -37,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
@@ -100,36 +99,6 @@ We welcome feature ideas! Please:
 - Consider implementation approach
 - Be open to discussion
 
-## 🖥️ Local viewer SPA
-
-`strix view` serves a prebuilt web UI whose source lives in
-`strix/interface/viewer/frontend/` (a Vite + React project) and whose built output is
-committed to `strix/interface/viewer/static/` and shipped in the package. End users never
-run a JS build. If you change anything under `strix/interface/viewer/frontend/`, rebuild
-and commit the output:
-
-```bash
-make viewer   # or: cd strix/interface/viewer/frontend && npm ci && npm run build
-```
-
-Commit both the source change and the regenerated `strix/interface/viewer/static/`.
-
-## Package builds
-
-Editable installs do not need Go; they run the TUI from source (`go run`).
-
-Wheels always bundle the matching Go sidecar and are platform-specific:
-
-```bash
-make wheel
-```
-
-The build hook (`scripts/tui_sidecar_hook.py`) compiles the sidecar, embeds it as
-`strix/bin/strix-tui`, and assigns the current platform tag. It requires Go
-1.24.x or newer and fails rather than producing a wheel without the sidecar.
-`scripts/build.sh` and `strix.spec` are likewise strict for frozen PyInstaller
-releases.
-
 ## 🤝 Community
 
 - **Discord**: [Join our community](https://discord.gg/strix-ai)

Makefile

@@ -1,6 +1,4 @@
-.PHONY: help install dev-install format lint type-check security check-all clean pre-commit setup-dev dev viewer wheel tui-build tui-test tui-lint
-
-TUI_BINARY := build/sidecar/strix-tui$(if $(filter Windows_NT,$(OS)),.exe)
+.PHONY: help install dev-install format lint type-check test test-cov clean pre-commit setup-dev
 
 help:
 	@echo "Available commands:"
@@ -10,86 +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 "  viewer        - Rebuild the local-viewer SPA (commit the output)"
-	@echo "  wheel         - Build a platform wheel with the bundled Go sidecar"
 	@echo "  clean         - Clean up cache files and artifacts"
-	@echo "  tui-build     - Build the Bubble Tea TUI"
-	@echo "  tui-test      - Test the Bubble Tea TUI"
-	@echo "  tui-lint      - Vet and format-check the Bubble Tea TUI"
 
 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!"
 
-viewer:
-	@echo "🖥️  Building the local-viewer SPA..."
-	cd strix/interface/viewer/frontend && npm ci && npm run build
-	@echo "✅ Viewer built to strix/interface/viewer/static/ (commit the changes)."
-
-wheel:
-	uv build --wheel
-
-dev: format lint type-check
+dev: format lint type-check test
 	@echo "✅ Development cycle complete!"
-
-tui-build:
-	mkdir -p build/sidecar
-	cd strix/interface/tui && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o ../../../$(TUI_BINARY) ./cmd/strix-tui
-
-tui-test:
-	cd strix/interface/tui && go test -race ./...
-
-tui-lint:
-	cd strix/interface/tui && test -z "$$(gofmt -l .)" && go vet ./...

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/>
 
@@ -27,29 +27,29 @@
 <a href="https://x.com/strix_ai"><img src="https://github.com/usestrix/.github/raw/main/imgs/X.png" height="40" alt="Follow on X"></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>
 <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>
 
 </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,89 +96,51 @@ 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)
 
 ---
 
-## 🤖 Use Strix from Your Coding Agent
-
-Strix is agent-ready. Give Claude Code, Cursor, Codex, or any [SKILL.md-compatible](https://agentskills.io) agent the ability to run pentests, fix findings, and set up CI scanning:
-
-```bash
-npx skills add usestrix/strix
-```
-
-This installs four skills: **penetration-testing-with-strix** (run headless scans and read results), **managed-pentesting-with-strix** (drive the managed [app.strix.ai](https://app.strix.ai) platform via REST — no local Docker or LLM key), **fix-security-vulnerabilities-with-strix** (remediate + re-scan to verify), and **ci-security-scanning-with-strix** (PR scanning in CI). Agents can run Strix two ways with the same engine — the open-source CLI locally, or the managed cloud when there's no local infra — and read [`AGENTS.md`](AGENTS.md) for a quick reference, [docs.strix.ai/llms.txt](https://docs.strix.ai/llms.txt) for the CLI docs, and [docs.app.strix.ai](https://docs.app.strix.ai) for the API.
-
----
-
 ## ✨ 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
-
----
-
-## 🖥️ Local Web Viewer
-
-Every scan writes its results to disk as it runs. Bring them up in a local dashboard with a single command:
-
-```bash
-# Open the most recent run
-strix view
-
-# ...or open a specific run by name
-strix view my-run-name
-```
-
-`strix view` starts a lightweight local server (bound to `127.0.0.1` on a random port) and opens your browser to a private, tokened link. Nothing leaves your machine: the dashboard reads the run's files straight off disk, with no cloud account or upload required. The UI ships prebuilt with Strix, so there is no extra install and no JS build step.
-
-### What's in the dashboard
-
-- **Overview**: run status, target, and a severity breakdown of everything found so far.
-- **Vulnerabilities**: each validated finding with its severity, details, and reproduction steps.
-- **Agent graph**: a live map of the multi-agent team, showing which agent is doing what.
-- **Steering**: send instructions to a live scan from the browser to redirect the agents mid-run.
-- **History**: browse past runs on this machine and jump between them.
-- **Reports**: generate a shareable report and email it to yourself or your 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
 
 ---
 
@@ -197,28 +159,6 @@ strix --target https://github.com/org/repo
 strix --target https://your-app.com
 ```
 
-### API Testing (OpenAPI / Swagger / Postman)
-
-Point Strix at an API contract and it tests every declared endpoint instead of
-having to discover them by crawling. Pair the spec with the live base URL so the
-agent knows where to send traffic:
-
-```bash
-# OpenAPI / Swagger file (.json / .yaml)
-strix --target ./openapi.yaml --target https://api.your-app.com
-
-# Postman collection export
-strix --target ./collection.postman_collection.json --target https://api.your-app.com
-
-# Postman collection pulled live by id (no manual export)
-export POSTMAN_API_KEY="PMAK-..."
-strix --target postman://<collection-uuid>
-
-# ...with a Postman environment to resolve {{baseUrl}} / token variables
-strix --target "postman://<collection-uuid>?env=<environment-uuid>"
-```
-
-
 ### Advanced Testing Scenarios
 
 ```bash
@@ -228,9 +168,6 @@ 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
 
@@ -246,7 +183,7 @@ 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
@@ -301,35 +238,21 @@ export STRIX_REASONING_EFFORT="high"  # control thinking effort (default: high,
 > [!NOTE]
 > Strix automatically saves your configuration to `~/.strix/cli-config.json`, so you don't have to re-enter it on every run.
 
-#### Sign in with a ChatGPT subscription
-
-Instead of a metered API key, you can run Strix on your ChatGPT Plus/Pro subscription:
-
-```bash
-strix auth login chatgpt      # sign in with your ChatGPT account
-
-export STRIX_LLM="chatgpt/gpt-5.4"   # chatgpt/<model> runs on the subscription
-strix --target ./app-directory
-
-strix auth status             # show the active sign-in
-strix auth logout             # forget the sign-in
-```
-
 **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
 
@@ -345,11 +268,10 @@ Have questions? Found a bug? Want to contribute? **[Join our Discord!](https://d
 
 ## Acknowledgements
 
-Strix builds on the incredible work of open-source projects like [LiteLLM](https://github.com/BerriAI/litellm), [Caido](https://github.com/caido/caido), [Nuclei](https://github.com/projectdiscovery/nuclei), [Playwright](https://github.com/microsoft/playwright), and [Bubble Tea](https://github.com/charmbracelet/bubbletea). Huge thanks to their maintainers!
+Strix builds on the incredible work of open-source projects like [LiteLLM](https://github.com/BerriAI/litellm), [Caido](https://github.com/caido/caido), [Nuclei](https://github.com/projectdiscovery/nuclei), [Playwright](https://github.com/microsoft/playwright), and [Textual](https://github.com/Textualize/textual). Huge thanks to their maintainers!
 
 
 > [!WARNING]
-> **Authorized use only.** Strix actively tests the targets you point it at, so only run it against systems you own or have **explicit, written permission** to test, and stay within the agreed scope. Unauthorized testing is illegal in most jurisdictions.
-> You alone are responsible for obtaining authorization and complying with the law. Strix is provided "as is" with no warranty or liability for misuse.
+> Only test apps you own or have permission to test. You are responsible for using Strix ethically and legally.
 
 </div>

containers/Dockerfile

@@ -1,27 +1,3 @@
-# ---------------------------------------------------------------------------
-# Builder stage: compile the Go tools here so the Go toolchain (~225MB) and the
-# module/build caches never reach the runtime image. The resulting binaries are
-# statically linked and copied into the final stage.
-# ---------------------------------------------------------------------------
-FROM kalilinux/kali-rolling:latest AS gobuilder
-
-RUN apt-get update && \
-    apt-get install -y kali-archive-keyring && \
-    apt-get update && \
-    apt-get install -y --no-install-recommends golang-go git ca-certificates
-
-ENV GOBIN=/out/bin
-RUN mkdir -p /out/bin && \
-    go install -v github.com/projectdiscovery/httpx/cmd/httpx@latest && \
-    go install -v github.com/projectdiscovery/katana/cmd/katana@latest && \
-    go install -v github.com/projectdiscovery/cvemap/cmd/vulnx@latest && \
-    go install -v github.com/jaeles-project/gospider@latest && \
-    go install -v github.com/projectdiscovery/interactsh/cmd/interactsh-client@latest && \
-    go install -v golang.org/x/vuln/cmd/govulncheck@latest
-
-# ---------------------------------------------------------------------------
-# Runtime stage
-# ---------------------------------------------------------------------------
 FROM kalilinux/kali-rolling:latest
 
 LABEL description="AI Agent Penetration Testing Environment with Comprehensive Automated Tools"
@@ -36,29 +12,38 @@ 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 && \
     apt-get install -y --no-install-recommends \
     wget curl git vim nano unzip tar \
     apt-transport-https ca-certificates gnupg lsb-release \
-    software-properties-common \
-    gcc libc6-dev \
-    python3 python3-pip python3-venv python3-setuptools \
+    build-essential software-properties-common \
+    gcc libc6-dev pkg-config libpcap-dev libssl-dev \
+    python3 python3-pip python3-dev python3-venv python3-setuptools \
+    golang-go \
     net-tools dnsutils whois \
-    file xxd \
     jq parallel ripgrep grep \
-    less procps htop \
+    less man-db procps htop \
     iproute2 iputils-ping netcat-traditional \
     nmap ncat ndiff \
     sqlmap nuclei subfinder naabu ffuf \
     nodejs npm pipx \
-    golang-go \
     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)
@@ -85,19 +70,26 @@ 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
 
-# Go tools are built in the gobuilder stage; copy the static binaries only.
-COPY --from=gobuilder --chown=pentester:pentester /out/bin/ /home/pentester/go/bin/
+RUN go install -v github.com/projectdiscovery/httpx/cmd/httpx@latest && \
+    go install -v github.com/projectdiscovery/katana/cmd/katana@latest && \
+    go install -v github.com/projectdiscovery/cvemap/cmd/vulnx@latest && \
+    go install -v github.com/jaeles-project/gospider@latest && \
+    go install -v github.com/projectdiscovery/interactsh/cmd/interactsh-client@latest
 
 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
@@ -107,32 +99,7 @@ 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 && \
-    npm cache clean --force && \
-    # ast-grep ships two identical binaries (`ast-grep` and `sg`); dedupe (~52MB)
-    ln -sf ast-grep /home/pentester/.npm-global/lib/node_modules/@ast-grep/cli/sg
-
-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
-ENV AGENT_BROWSER_IDLE_TIMEOUT_MS=180000
-USER root
-RUN set -eu; \
-    { \
-        for var in AGENT_BROWSER_EXECUTABLE_PATH AGENT_BROWSER_USER_AGENT \
-                   AGENT_BROWSER_ARGS AGENT_BROWSER_SCREENSHOT_DIR \
-                   AGENT_BROWSER_IDLE_TIMEOUT_MS; do \
-            eval "value=\${$var}"; \
-            printf 'export %s="${%s:-%s}"\n' "$var" "$var" "$value"; \
-        done; \
-    } > /tmp/agent-browser.sh; \
-    install -m 0644 /tmp/agent-browser.sh /etc/profile.d/agent-browser.sh; \
-    rm /tmp/agent-browser.sh; \
-    env -i bash -lc 'test "${AGENT_BROWSER_IDLE_TIMEOUT_MS}" = "180000"'
-USER pentester
-RUN /home/pentester/.npm-global/bin/agent-browser doctor --offline --quick
+    npm install -g tree-sitter-cli@latest
 
 RUN set -eux; \
     TS_PARSER_DIR="/home/pentester/.tree-sitter/parsers"; \
@@ -171,14 +138,7 @@ RUN git clone https://github.com/aravind0x7/JS-Snooper.git && \
 
 USER root
 
-# Install trufflehog into a pentester-owned dir on PATH so its runtime self-update
-# (which replaces the binary in place) succeeds: as non-root `pentester` it cannot
-# overwrite a root-owned binary under /usr/local/bin, which otherwise fails with
-# "cannot move binary" and aborts the scan. Pin the initial version for
-# reproducible builds; self-update then pulls fresh detectors at runtime.
-ARG TRUFFLEHOG_VERSION=3.95.9
-RUN curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -b /home/pentester/.local/bin "v${TRUFFLEHOG_VERSION}" && \
-    chown -R pentester:pentester /home/pentester/.local
+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 \
@@ -192,6 +152,8 @@ RUN set -eux; \
     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
+
 RUN curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sh -s -- -b /usr/local/bin
 
 RUN apt-get install -y wapiti
@@ -207,19 +169,14 @@ USER root
 
 RUN apt-get autoremove -y && \
     apt-get autoclean && \
-    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* && \
-    # Purge non-English locales (~160MB)
-    find /usr/share/locale -mindepth 1 -maxdepth 1 -type d \
-        ! -name 'en' ! -name 'en_US' ! -name 'C' -exec rm -rf {} + && \
-    # Remove package documentation and man pages not needed at runtime (~95MB)
-    rm -rf /usr/share/doc/* /usr/share/doc-base/* /usr/share/man/*
+    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"; \
@@ -228,39 +185,39 @@ 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
 
+COPY pyproject.toml poetry.lock ./
+
 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 \
-        requests httpx beautifulsoup4 lxml pyjwt cryptography && \
-    /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
+RUN poetry install --no-root --without dev --extras sandbox
+RUN poetry run playwright install chromium
 
-COPY --chown=pentester:pentester strix/tools/proxy/caido_api.py /opt/strix-python/caido_api.py
-ENV PYTHONPATH=/opt/strix-python
+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
 
-# Login shells (e.g. `bash -lc`) source /etc/profile, which on Debian/Kali
-# hard-resets PATH and drops the image's ENV PATH entries. Re-add the same
-# directories here — including /app/.venv/bin — so `python3`/`pip` resolve to
-# the venv (which ships requests, httpx, bs4, lxml, pyjwt, cryptography, and the
-# Caido SDK) instead of the externally-managed system interpreter.
-RUN echo 'export PATH="/home/pentester/go/bin:/home/pentester/.local/bin:/home/pentester/.npm-global/bin:/app/.venv/bin:$PATH"' >> /home/pentester/.bashrc && \
-    echo 'export PATH="/home/pentester/go/bin:/home/pentester/.local/bin:/home/pentester/.npm-global/bin:/app/.venv/bin:$PATH"' >> /home/pentester/.profile
+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
 
 USER root
 COPY containers/docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh

containers/docker-entrypoint.sh

@@ -1,22 +1,6 @@
 #!/bin/bash
 set -e
 
-if [ -n "${STRIX_HOST_UID:-}" ] && [ "${STRIX_HOST_UID}" != "0" ] && [ "${STRIX_HOST_UID}" != "$(id -u)" ]; then
-  exec sudo -E -- bash -c '
-    set -e
-    gid="${STRIX_HOST_GID:-$STRIX_HOST_UID}"
-    old_uid="$1"
-    old_gid="$2"
-    export PATH="$3"
-    shift 3
-    sed -i "s|^pentester:x:${old_uid}:${old_gid}:|pentester:x:${STRIX_HOST_UID}:${gid}:|" /etc/passwd
-    sed -i "s|^pentester:x:${old_gid}:|pentester:x:${gid}:|" /etc/group
-    chown -R "${STRIX_HOST_UID}:${gid}" /home/pentester /app/certs
-    chown "${STRIX_HOST_UID}:${gid}" /workspace
-    exec setpriv --reuid "${STRIX_HOST_UID}" --regid "${gid}" --init-groups "$0" "$@"
-  ' "$0" "$(id -u)" "$(id -g)" "$PATH" "$@"
-fi
-
 CAIDO_PORT=48080
 CAIDO_LOG="/tmp/caido_startup.log"
 
@@ -25,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 &
 
@@ -77,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..."
 
@@ -87,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
@@ -98,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
@@ -107,13 +138,10 @@ http_proxy=http://127.0.0.1:${CAIDO_PORT}
 https_proxy=http://127.0.0.1:${CAIDO_PORT}
 EOF
 
-# Use POSIX `.` (not the bashism `source`) so these lines are safe when the rc
-# files are read by a POSIX shell (e.g. `sh -lc`), which otherwise fails with
-# "source: not found". `.` is understood by bash, zsh, and dash alike.
-echo ". /etc/profile.d/proxy.sh" >> ~/.bashrc
-echo ". /etc/profile.d/proxy.sh" >> ~/.zshrc
+echo "source /etc/profile.d/proxy.sh" >> ~/.bashrc
+echo "source /etc/profile.d/proxy.sh" >> ~/.zshrc
 
-. /etc/profile.d/proxy.sh
+source /etc/profile.d/proxy.sh
 
 echo "✅ System-wide proxy configuration complete"
 
@@ -123,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

@@ -19,14 +19,6 @@ Configure Strix using environment variables or a config file.
   Custom API base URL. Also accepts `OPENAI_API_BASE`, `LITELLM_BASE_URL`, or `OLLAMA_API_BASE`.
 </ParamField>
 
-<ParamField path="LLM_EXTRA_HEADERS" type="string">
-  Extra HTTP headers sent on every LLM request, as a JSON object (e.g.
-  `{"X-Feature-Key":"value","X-Tenant":"acme"}`). Useful for OpenAI-compatible
-  gateways that require attribution or routing headers in addition to the bearer
-  token. The bearer token itself still comes from `LLM_API_KEY`. Applies to both
-  the LiteLLM and native OpenAI routing paths.
-</ParamField>
-
 <ParamField path="LLM_TIMEOUT" default="300" type="integer">
   Request timeout in seconds for LLM calls.
 </ParamField>
@@ -36,56 +28,33 @@ Configure Strix using environment variables or a config file.
 </ParamField>
 
 <ParamField path="STRIX_REASONING_EFFORT" default="high" type="string">
-  Control thinking effort for reasoning models. Valid values: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. Defaults to `medium` for quick scan mode.
+  Control thinking effort for reasoning models. Valid values: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`. Defaults to `medium` for quick scan mode.
 </ParamField>
 
 <ParamField path="STRIX_MEMORY_COMPRESSOR_TIMEOUT" default="30" type="integer">
   Timeout in seconds for memory compression operations (context summarization).
 </ParamField>
 
-### Dedicated deduplication model
-
-Finding deduplication is a cheap, structured classification task. By default it
-runs on the main model, but you can route it to a smaller/cheaper model without
-affecting the agents that do the actual testing.
-
-<ParamField path="STRIX_DEDUPE_MODEL" type="string">
-  Model used to judge whether a candidate finding duplicates an existing report.
-  Falls back to `STRIX_LLM` when unset.
-</ParamField>
-
-<ParamField path="DEDUPE_LLM_API_KEY" type="string">
-  Optional provider key for the deduplication model.
-</ParamField>
-
-<ParamField path="DEDUPE_LLM_API_BASE" type="string">
-  Optional custom API base URL for the deduplication model. Use when the dedupe
-  model runs on a different endpoint than the main model.
-</ParamField>
-
-<ParamField path="DEDUPE_LLM_EXTRA_HEADERS" type="string">
-  Optional JSON object of extra HTTP headers sent on every deduplication-model
-  request, e.g. `{"X-Feature-Key":"value"}`. A dedicated dedupe model never
-  inherits `LLM_EXTRA_HEADERS`; set this when its endpoint needs custom headers.
-</ParamField>
-
-<ParamField path="STRIX_DEDUPE_REASONING_EFFORT" type="string">
-  Reasoning effort for the deduplication model. Defaults to the model's own
-  baseline when unset.
-</ParamField>
-
 ## Optional Features
 
 <ParamField path="PERPLEXITY_API_KEY" type="string">
   API key for Perplexity AI. Enables real-time web search during scans for OSINT and vulnerability research.
 </ParamField>
 
-<ParamField path="POSTMAN_API_KEY" type="string">
-  Postman API key (`PMAK-…`). Enables fetching Postman collections by id as a target (`postman://<collection-uid>`), and Postman environments (`postman://<collection-uid>?env=<environment-uid>`) to resolve collection variables. Not needed when passing a local collection export file.
+<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">
@@ -110,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.3.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>
 

docs/advanced/skills.mdx

@@ -68,10 +68,10 @@ Framework-specific testing patterns.
 
 Third-party service and platform security.
 
-| Skill      | Coverage                                               |
-| ---------- | ------------------------------------------------------ |
-| `supabase` | Supabase RLS bypasses, auth issues                     |
-| `firebase` | Firebase Firestore, Storage rules, Auth, and Functions |
+| Skill                | Coverage                           |
+| -------------------- | ---------------------------------- |
+| `supabase`           | Supabase RLS bypasses, auth issues |
+| `firebase_firestore` | Firestore rules, Firebase auth     |
 
 ### Protocols
 
@@ -81,14 +81,6 @@ Protocol-specific testing techniques.
 | --------- | ------------------------------------------------ |
 | `graphql` | GraphQL introspection, batching, resolver issues |
 
-### Reconnaissance
-
-Passive discovery and attack-surface mapping techniques.
-
-| Skill             | Coverage                                                        |
-| ----------------- | --------------------------------------------------------------- |
-| `asset_discovery` | CT, TLS SAN pivoting, passive DNS, and ASN/IP asset enumeration |
-
 ### Tooling
 
 Sandbox CLI playbooks for core recon and scanning tools.

docs/contributing.mdx

@@ -8,9 +8,8 @@ description: "Contribute to Strix development"
 ### Prerequisites
 
 - Python 3.12+
-- Latest Go 1.24.x patch (only for Bubble Tea TUI development and release artifacts)
 - Docker (running)
-- [uv](https://docs.astral.sh/uv/)
+- Poetry
 - Git
 
 ### Local Development
@@ -27,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">
@@ -39,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>
@@ -75,22 +74,6 @@ Skills are specialized knowledge packages that enhance agent capabilities. They
 - Small, focused functions
 - Meaningful variable names
 
-## Package Builds
-
-Editable installs do not require Go; they run the TUI from source (`go run`).
-
-Wheels are intentionally strict: they always bundle the matching Go sidecar and
-are platform-specific.
-
-```bash
-make wheel
-```
-
-The build hook (`scripts/tui_sidecar_hook.py`) requires Go 1.24.x or newer, embeds
-the sidecar as `strix/bin/strix-tui`, and assigns the current platform tag.
-Frozen releases built by `scripts/build.sh` and `strix.spec` also require the
-sidecar.
-
 ## Reporting Issues
 
 Include:

docs/docs.json

@@ -38,7 +38,6 @@
               "llm-providers/vertex",
               "llm-providers/bedrock",
               "llm-providers/azure",
-              "llm-providers/novita",
               "llm-providers/local"
             ]
           },
@@ -46,8 +45,7 @@
             "group": "Integrations",
             "pages": [
               "integrations/github-actions",
-              "integrations/ci-cd",
-              "integrations/coding-agents"
+              "integrations/ci-cd"
             ]
           },
           {

docs/integrations/coding-agents.mdx

@@ -1,61 +0,0 @@
----
-title: "Coding Agents"
-description: "Use Strix from Claude Code, Cursor, Codex, and other AI agents"
----
-
-Strix is built to be driven by AI coding agents. Install the official agent skills and your agent knows how to run pentests, remediate findings, and wire Strix into CI.
-
-## Install the Skills
-
-Works with any agent that supports the open [SKILL.md standard](https://agentskills.io) — Claude Code, Cursor, Codex, Gemini CLI, OpenCode, and dozens more:
-
-```bash
-npx skills add usestrix/strix
-```
-
-| Skill | What your agent learns |
-|-------|------------------------|
-| `penetration-testing-with-strix` | Run headless scans against code, URLs, domains, or IPs — self-hosted CLI or managed cloud — with budget caps, and read the results |
-| `managed-pentesting-with-strix` | Drive the managed [app.strix.ai](https://app.strix.ai) platform over REST — no local Docker or LLM key needed |
-| `fix-security-vulnerabilities-with-strix` | Triage findings, fix root causes, and re-run Strix to verify each fix |
-| `ci-security-scanning-with-strix` | Add PR security scanning to GitHub Actions or any CI (self-hosted CLI or managed app) |
-
-Install a single skill with `npx skills add usestrix/strix --skill penetration-testing-with-strix`, or use one without installing:
-
-```bash
-npx skills use usestrix/strix@penetration-testing-with-strix | claude
-```
-
-## Two ways to run — self-hosted or managed
-
-Both use the same engine and produce the same validated findings and SARIF, so agents can pick per situation or combine them:
-
-- **Open-source CLI (self-hosted)** — runs locally in a Docker sandbox with your own LLM key. Free, fully local, air-gap capable. Best for local dev loops and full control.
-- **Managed cloud** — runs on Strix's infrastructure via the [app.strix.ai REST API](https://docs.app.strix.ai). No Docker, no LLM key, no local install; adds team dashboards, scheduling, PR reviews, and downloadable PDF/DOCX reports (Enterprise plan). Best in sandboxed/CI environments and for teams. Create an API token under **Settings → API Access**; the `managed-pentesting-with-strix` skill has the full flow.
-
-## Agent-Friendly Interfaces
-
-Everything an agent needs is machine-readable:
-
-- **Headless CLI** — `strix -n` runs without the TUI and exits with `0` (clean), `1` (error), or `2` (vulnerabilities found).
-- **REST API** — the managed platform exposes a documented [OpenAPI](https://docs.app.strix.ai/openapi.json) at `https://app.strix.ai/api/v1` (scans, vulnerabilities, assets, PR reviews, schedules, webhooks) with bearer tokens and scopes.
-- **Structured results** — every run writes `vulnerabilities.json`, `vulnerabilities.csv`, `findings.sarif` (SARIF 2.1.0), and per-finding Markdown under `strix_runs/<run-name>/`; the cloud exposes the same as JSON plus SARIF export.
-- **Budget controls** — `--max-budget` and `--max-turns` give agents hard cost/time caps.
-- **`AGENTS.md`** — the [repository's agent guide](https://github.com/usestrix/strix/blob/main/AGENTS.md) with a quick reference.
-- **`llms.txt`** — this documentation is indexed at [docs.strix.ai/llms.txt](https://docs.strix.ai/llms.txt) and fully exported at [docs.strix.ai/llms-full.txt](https://docs.strix.ai/llms-full.txt); every page is also available as Markdown by appending `.md` to its URL.
-
-## Example Prompts
-
-Once the skills are installed, prompts like these just work:
-
-```text
-Pentest this repo with Strix (quick mode, $10 budget) and summarize the findings.
-```
-
-```text
-Fix all critical and high findings from the last Strix run, then re-scan to verify.
-```
-
-```text
-Add Strix security scanning to our GitHub Actions so every PR gets tested.
-```

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/local.mdx

@@ -54,55 +54,3 @@ If you use LM Studio, vLLM, or other runners:
 export STRIX_LLM="openai/local-model"
 export LLM_API_BASE="http://localhost:1234/v1"  # Adjust port as needed
 ```
-
-### Gateways that require custom headers
-
-Some OpenAI-compatible gateways require extra HTTP headers (for attribution or
-tenant routing) alongside the bearer token. Set them with `LLM_EXTRA_HEADERS` as
-a JSON object — they are sent on every request:
-
-```bash
-export STRIX_LLM="openai/your-model"
-export LLM_API_BASE="https://your-gateway.example/v1"
-export LLM_API_KEY="your-bearer-token"          # sent as Authorization: Bearer ...
-export LLM_EXTRA_HEADERS='{"X-Feature-Key":"value","X-Tenant":"acme"}'
-```
-
-For endpoints behind a private CA, point Strix at your certificate bundle with
-the standard `SSL_CERT_FILE=/path/to/ca-bundle.pem` — never disable TLS
-verification against a real endpoint.
-
-## Tool calling must return structured `tool_calls`
-
-Strix is entirely tool-driven: every working turn must be a **native** function/tool call. If your inference server returns the tool call as plain assistant text instead of a structured `tool_calls` field, Strix never sees a call it can execute, so the agent makes no real progress — it re-prompts the model for a tool call and gives up once its recovery attempts are exhausted.
-
-This is almost always an **inference-server configuration** problem, not a model or Strix problem. Common symptoms are the model printing a call as text such as:
-
-```text
-<tool_call>{"name": "exec_command", "arguments": {"cmd": "nmap ..."}}</tool_call>
-exec_command(cmd="nmap ...", timeout=180)
-{"action": "exec_command", "params": {"cmd": "nmap ..."}}
-```
-
-The fix belongs on the inference server: it must be configured to parse the model's tool tokens into structured `tool_calls`. A correctly configured endpoint either returns a structured call or rejects the request outright — it never leaks the call as text.
-
-### Fixes by server
-
-**llama.cpp (`llama-server`)**
-- Run with `--jinja` and a correct tool-use chat template (`--chat-template` / `--chat-template-file` matching the model). Recent builds enable `--jinja` by default — **upgrade** if yours doesn't.
-- For thinking models, align or disable reasoning (`--reasoning-format`, `-rea off`) so it doesn't break tool-call parsing.
-- A low temperature (e.g. `--temp 0.2`) improves tool-call reliability.
-
-**Ollama**
-- Use a recent Ollama and a model whose template wires tools. Modern Ollama refuses tools (`tools param requires --jinja flag`) if the template lacks tool support.
-- For reasoning models (e.g. qwen3), disable the model's **thinking** mode — thinking left on frequently pushes the tool call into the text `content` instead of the structured `tool_calls` field. Turn it off on the Ollama side (a non-thinking model variant, or `think: false` in the model's parameters / `Modelfile`).
-- Raise **`num_ctx`** to at least 16k–32k. Strix sends a large system prompt plus many tool schemas; at Ollama's small default context the tool definitions are truncated out of the prompt and the model stops emitting valid calls. A short test prompt can look fine while a real scan fails, so set this explicitly rather than inferring it from a quick check.
-
-**vLLM**
-- Start with `--enable-auto-tool-choice`, a matching `--tool-call-parser` (`hermes`, `qwen3_xml`, or `llama3_json`), and a matching `--reasoning-parser` for reasoning models.
-
-A low sampling temperature (roughly 0.2–0.6, depending on the family) also measurably reduces malformed tool calls on open-weight models. Set it on the server or in your model's parameters.
-
-<Warning>
-Even correctly configured, small models (< ~30B) emit malformed or text-form tool calls far more often than frontier models. Prefer a capable model for reliable agentic behavior.
-</Warning>

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/usage/cli.mdx

@@ -6,27 +6,13 @@ description: "Command-line options for Strix"
 ## Basic Usage
 
 ```bash
-strix (--target <target> | --target-list <path>) [options]
+strix --target <target> [options]
 ```
 
 ## Options
 
-<ParamField path="--target, -t" type="string">
-  Target to test. Accepts URLs, repositories, local directories, domains, IP addresses, API spec files (OpenAPI/Swagger `.json`/`.yaml`, a Postman collection export), or a live Postman collection by id (`postman://<collection-uuid>`). Can be specified multiple times. Fresh runs require at least one target source: `--target` or `--target-list`.
-
-  When the target is an API spec, Strix copies it into the agent's workspace and authorizes the base URLs it declares (including those resolved from a Postman environment) as in-scope hosts - so the agent reads the contract and tests the full declared surface instead of discovering endpoints by crawling. Pair the spec with the deployed base URL (e.g. `--target ./openapi.yaml --target https://api.example.com`) so the agent has a reachable host to attack.
-
-  <Note>
-    A local directory is mounted into the sandbox live and **writable**, so the agent edits your real files (`.git` excepted). Commit or stash first.
-  </Note>
-
-  <Note>
-    Fetching a Postman collection by id requires `POSTMAN_API_KEY`. Add `?env=<environment-uuid>` to also pull a Postman environment, which resolves `{{baseUrl}}` / token variables the collection references (e.g. `postman://<collection-uuid>?env=<environment-uid>`).
-  </Note>
-</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 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">
@@ -57,59 +43,6 @@ strix (--target <target> | --target-list <path>) [options]
   Path to a custom config file (JSON) to use instead of `~/.strix/cli-config.json`.
 </ParamField>
 
-<ParamField path="--max-budget" 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.
-
-  In non-interactive mode (`-n`), once the running cost reaches the threshold,
-  the scan stops cleanly with a `stopped` status (not a failure) and the sandbox
-  is torn down. Sub-agents are stopped early, at 90% of the budget, reserving
-  the final slice for the root agent to wind down and produce the final report.
-
-  In interactive mode, reaching the budget pauses the scan instead of ending
-  it: every agent parks, and sending any message resumes the scan with the cap
-  extended by the original budget amount. There is no sub-agent reserve in
-  interactive mode.
-
-  As the budget is approached, graduated wrap-up warnings are surfaced to
-  **every** agent so they can finish their work and call their lifecycle tool
-  before the hard stop. The bands sit just below each role's own stop point: the
-  root is warned at **70%, 85% and 95%** (it stops at 100%), while sub-agents are
-  warned at **75%, 80% and 85%** (they stop at the 90% reserve). In interactive
-  mode every agent uses the **70%, 85% and 95%** bands. Percentages shown in the
-  warnings are the real cumulative spend against the full budget.
-
-  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>
-
-<ParamField path="--max-turns" type="integer" default="500">
-  Maximum number of turns (one model response plus its tool round) allotted to
-  **each** agent, applied per run. When an agent reaches this limit it is
-  force-stopped.
-
-  As the limit is approached, graduated wrap-up warnings (at 70%, 85% and 95%)
-  are injected into that agent's next model turn so it can prioritise its
-  remaining work and call its lifecycle tool (`finish_scan` for the root agent,
-  `agent_finish` for sub-agents) before the hard stop.
-
-  Must be greater than `0`.
-</ParamField>
-
 ## Examples
 
 ```bash
@@ -125,29 +58,16 @@ strix --target api.example.com --instruction "Focus on IDOR and auth bypass"
 # CI/CD mode
 strix -n --target ./ --scan-mode quick
 
-# Cap cost and per-agent turns
-strix --target https://example.com --max-budget 25 --max-turns 300
-
 # 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
-
-# API spec + live target (OpenAPI/Swagger file or Postman collection)
-strix -t ./openapi.yaml -t https://api.example.com
-
-# Postman collection pulled live by id (+ optional environment)
-strix -t "postman://<collection-uuid>?env=<environment-uuid>"
-
-# Targets from a file
-strix --target-list ./targets.txt
 ```
 
 ## Exit Codes
 
 | Code | Meaning |
 |------|---------|
-| 0 | Scan completed successfully (interactive mode always exits `0`; in headless mode, `0` means no vulnerabilities were found) |
-| 1 | A fatal error occurred before or during the scan (e.g. missing environment variables, Docker unavailable, invalid config file, diff-scope resolution failure, or an unhandled error) |
+| 0 | Scan completed, no vulnerabilities found |
 | 2 | Vulnerabilities found (headless mode only) |

pyproject.toml

@@ -1,13 +1,10 @@
-[project]
+[tool.poetry]
 name = "strix-agent"
-version = "1.5.3"
+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,70 +29,81 @@ classifiers = [
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
 ]
-dependencies = [
-  "openai-agents[litellm]>=0.19.0,<0.20",
-  "openai>=2.45.0,<3",
-  "litellm",
-  "pydantic>=2.11.3",
-  "pydantic-settings>=2.13.0",
-  "rich",
-  "docker>=7.1.0",
-  "requests>=2.32.0",
-  "cvss>=3.2",
-  "caido-sdk-client>=0.2.0",
-  "reportlab>=4.0",
-  "pypdf>=5.0",
-  # Cap <49: 49.x drops the universal2 macOS wheel (arm64-only), which breaks
-  # the Intel macOS (macos-x86_64) release build's `uv sync --frozen`.
-  "cryptography>=48.0.1,<49",
-  "pyyaml>=6.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",
-  "types-requests>=2.32",
-]
+[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"]
-# The prebuilt viewer bundle under strix/interface/viewer/static/ ships automatically
-# (hatchling includes non-.py files under the package). The Vite SOURCE lives
-# under the package dir too (strix/interface/viewer/frontend/) but must never ship in the wheel.
-exclude = [
-  "strix/interface/viewer/frontend",
-  "strix/interface/viewer/frontend/**",
-  # Go TUI SOURCE lives under the package dir but must never ship in the wheel;
-  # the compiled sidecar is force-included as strix/bin/strix-tui instead.
-  "strix/interface/tui/cmd/**",
-  "strix/interface/tui/internal/**",
-  "strix/interface/tui/go.mod",
-  "strix/interface/tui/go.sum",
-]
-
-[tool.hatch.build.targets.wheel.hooks.custom]
-path = "scripts/tui_sidecar_hook.py"
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
 
 # ============================================================================
 # Type Checking Configuration
@@ -126,23 +134,34 @@ pretty = true
 [[tool.mypy.overrides]]
 module = [
     "litellm.*",
+    "tenacity.*",
+    "numpydoc.*",
     "rich.*",
+    "IPython.*",
+    "openhands_aci.*",
+    "playwright.*",
+    "uvicorn.*",
     "jinja2.*",
-    "cvss.*",
-    "docker.*",
-    "caido_sdk_client.*",
     "pydantic_settings.*",
-    "reportlab.*",
-    "pypdf.*",
-    "yaml.*",
-    "pygments.*",
+    "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)
@@ -154,6 +173,7 @@ line-length = 100
 extend-exclude = [
     ".git",
     ".mypy_cache",
+    ".pytest_cache",
     ".ruff_cache",
     "__pycache__",
     "build",
@@ -189,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
@@ -226,89 +247,21 @@ ignore = [
 ]
 
 [tool.ruff.lint.per-file-ignores]
-# Test doubles use fixture tokens/passwords and match a callee signature whose
-# args they intentionally ignore.
-"tests/test_viewer_auth.py" = ["S105", "S106", "ARG001"]
-"tests/test_codex_auth.py" = ["S105", "S106", "SLF001"]
-# Hatchling loads the build hook by path, not as an importable package.
-"scripts/tui_sidecar_hook.py" = ["INP001"]
-# Stdlib HTTP handler overrides (do_GET/do_POST).
-"strix/interface/auth_cli.py" = ["N802"]
-"tests/test_codex_streaming.py" = ["N802"]
-"tests/test_disable_streaming.py" = ["N802"]
-"tests/test_tool_call_ids.py" = ["N802"]
-"tests/test_tool_call_limits.py" = ["N802", "SLF001"]
-"tests/test_stream_idle_timeout.py" = ["N802", "SLF001"]
-"tests/test_unknown_tool_recovery.py" = ["N802"]
-"tests/test_report_pdf.py" = ["S105", "S106"]
-# Stdlib HTTP handler overrides (do_GET/do_POST) and lazy imports that avoid a
-# circular dependency with strix.telemetry / strix.interface.viewer.report_pdf.
-"strix/interface/viewer/server.py" = ["N802", "PLC0415"]
-# Lazy telemetry import to avoid importing PostHog before the viewer starts.
-"strix/interface/viewer/cli.py" = ["PLC0415"]
-# 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", "PLC0415"]
-"strix/report/usage.py" = ["PLC0415"]
-# Lazy import of strix.config.models avoids a circular dependency between the
-# report pipeline and the config layer.
-"strix/report/dedupe.py" = ["PLC0415"]
-"strix/telemetry/logging.py" = ["PLC0415"]
-"strix/config/models.py" = ["PLC0415"]
-# Heavy inference deps (httpx, openai) imported lazily so auth-status checks
-# don't pull them in.
-"strix/config/codex.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/scan_setup.py" = ["PLC0415"]
-"strix/interface/main.py" = ["BLE001", "PLC0415", "PLR0912", "PLR0915"]
-"strix/interface/cli_args.py" = ["BLE001", "PLC0415", "PLR0912", "PLR0915"]
-"strix/interface/environment.py" = ["BLE001", "PLC0415", "PLR0912", "PLR0915"]
-# The Go TUI runtime and backend controller import interface modules lazily so
-# the sidecar entry point stays fast and avoids circular imports.
-"strix/interface/interactive.py" = ["PLC0415"]
-"strix/interface/tui/runtime.py" = ["PLC0415"]
-"strix/interface/tui/backend/controller.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
@@ -384,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"

renovate.json

@@ -1,30 +0,0 @@
-{
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": [
-    "config:recommended"
-  ],
-  "minimumReleaseAge": "7 days",
-  "internalChecksFilter": "strict",
-  "enabledManagers": [
-    "npm",
-    "github-actions",
-    "dockerfile",
-    "pep621"
-  ],
-  "packageRules": [
-    {
-      "groupName": "non-major dependencies",
-      "matchUpdateTypes": [
-        "minor",
-        "patch"
-      ]
-    },
-    {
-      "matchManagers": [
-        "github-actions",
-        "dockerfile"
-      ],
-      "pinDigests": true
-    }
-  ]
-}

scripts/build.sh

@@ -33,37 +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/"
-    exit 1
-fi
-
-if ! command -v go &> /dev/null; then
-    echo -e "${RED}Error: Go is not installed${NC}"
-    echo "Go 1.24 or newer is required to build the Bubble Tea TUI."
+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 Bubble Tea sidecar...${NC}"
-TUI_BINARY="build/sidecar/strix-tui"
-if [ "$OS_NAME" = "windows" ]; then
-    TUI_BINARY="${TUI_BINARY}.exe"
-fi
-mkdir -p build/sidecar
-(cd strix/interface/tui && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o "../../../$TUI_BINARY" ./cmd/strix-tui)
-
 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.3.0"
+STRIX_IMAGE="ghcr.io/usestrix/strix-sandbox:0.1.13"
 
 MUTED='\033[0;2m'
 RED='\033[0;31m'
@@ -41,7 +41,7 @@ fi
 
 combo="$os-$arch"
 case "$combo" in
-  linux-x86_64|linux-arm64|macos-x86_64|macos-arm64|windows-x86_64)
+  linux-x86_64|macos-x86_64|macos-arm64|windows-x86_64)
     ;;
   *)
     echo -e "${RED}Unsupported OS/Arch: $os/$arch${NC}"

scripts/tui_sidecar_hook.py

@@ -1,58 +0,0 @@
-"""Hatchling build hook that compiles and bundles the Go TUI sidecar."""
-
-from __future__ import annotations
-
-import os
-import shutil
-import subprocess
-import sysconfig
-from pathlib import Path
-from typing import Any
-
-from hatchling.builders.hooks.plugin.interface import BuildHookInterface
-
-
-class CustomBuildHook(BuildHookInterface[Any]):
-    """Compile the Bubble Tea sidecar and ship it inside the wheel.
-
-    The sidecar is the only interactive interface, so every wheel is a
-    platform wheel and a missing Go toolchain is a build failure.
-    """
-
-    def initialize(self, version: str, build_data: dict[str, Any]) -> None:
-        # Editable installs run from the checkout, where the TUI is started
-        # with ``go run``; there is nothing to bundle.
-        if version == "editable":
-            return
-
-        root = Path(self.root)
-        executable = "strix-tui.exe" if os.name == "nt" else "strix-tui"
-        output = root / "build" / "sidecar" / executable
-        output.parent.mkdir(parents=True, exist_ok=True)
-
-        go = shutil.which("go")
-        if go is None:
-            raise RuntimeError("Go 1.24 or newer is required to build the Bubble Tea TUI")
-        env = os.environ.copy()
-        env["CGO_ENABLED"] = "0"
-        subprocess.run(  # noqa: S603 - fixed build command using the resolved Go binary
-            [
-                go,
-                "build",
-                "-trimpath",
-                "-ldflags=-s -w",
-                "-o",
-                str(output),
-                "./cmd/strix-tui",
-            ],
-            cwd=root / "strix" / "interface" / "tui",
-            env=env,
-            check=True,
-        )
-
-        build_data["force_include"][str(output)] = f"strix/bin/{executable}"
-        build_data["pure_python"] = False
-        platform_tag = os.environ.get("STRIX_WHEEL_PLATFORM_TAG")
-        if not platform_tag:
-            platform_tag = sysconfig.get_platform().replace("-", "_").replace(".", "_")
-        build_data["tag"] = f"py3-none-{platform_tag}"

skills/ci-security-scanning-with-strix/SKILL.md

@@ -1,136 +0,0 @@
----
-name: ci-security-scanning-with-strix
-description: Add security scanning to CI/CD with Strix — GitHub Actions, GitLab CI, or any pipeline — so every pull request gets a diff-scoped AI pentest that blocks vulnerable code before it merges, with results as PR comments and SARIF uploaded to code scanning. Covers both the self-hosted open-source CLI (runs in your runner) and the managed app.strix.ai platform (GitHub/GitLab app or API, no runner infra). Use when the user asks to add security scanning, SAST/DAST, pentesting, vulnerability checks, or automated security review to their CI pipeline, pre-merge gate, or PR workflow.
-license: Apache-2.0
-metadata:
-  author: usestrix
-  homepage: https://docs.strix.ai
----
-
-# Set up Strix in CI/CD
-
-You can gate PRs two ways — pick based on the environment, or combine them:
-
-- **Managed platform (recommended for most teams)** — connect the GitHub/GitLab/Bitbucket app once and Strix reviews every PR with **no workflow file, no runner, no Docker, and no LLM key**. Results post as PR comments and land in the team dashboard. Best when you want zero CI maintenance, central tracking, or your runners lack Docker. See "Managed platform" below and the **managed-pentesting-with-strix** skill.
-- **Self-hosted OSS CLI in your runner** — run a diff-scoped scan as a pipeline step. Fully in your infra, free (BYO LLM key), no external account. Requires Docker on the runner. Best for air-gapped/self-hosted CI or when you don't want scans leaving your environment.
-
-Both fail the build on validated findings and both emit SARIF 2.1.0, so you can start with one and add the other later.
-
----
-
-# Option A — Self-hosted OSS CLI in the runner
-
-Run a diff-scoped Strix scan on every PR: only changed files are tested, `quick` mode keeps it fast, and exit code `2` fails the build when validated vulnerabilities are found.
-
-## GitHub Actions
-
-Create `.github/workflows/security.yml`:
-
-```yaml
-name: Security Scan
-
-on:
-  pull_request:
-
-jobs:
-  strix-scan:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0   # required for diff-scope resolution
-
-      - name: Install Strix
-        run: curl -sSL https://strix.ai/install | bash
-
-      - name: Run Security Scan
-        env:
-          STRIX_LLM: ${{ secrets.STRIX_LLM }}
-          LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
-        run: strix -n -t ./ --scan-mode quick --max-budget 10
-
-      # Don't fail open: a run that hits the hard budget stop exits 0 but leaves
-      # run.json status "stopped", not "completed". Enforce completion explicitly.
-      # This does not catch an agent that wrapped up early on a budget *warning*
-      # (it still calls finish_scan and records "completed"), so size the budget.
-      - name: Fail unless the scan completed
-        run: |
-          run_json=$(ls -t strix_runs/*/run.json | head -1)
-          status=$(jq -r .status "$run_json")
-          if [ "$status" != "completed" ]; then
-            echo "Strix run status is '$status' — the scan did not complete (likely budget exhausted). Raise --max-budget." >&2
-            exit 1
-          fi
-```
-
-Then tell the user to add two repository secrets: `STRIX_LLM` (model id, e.g. `openai/gpt-5.4`) and `LLM_API_KEY` (the provider key). Do not create these values yourself.
-
-Notes:
-- In CI/headless runs Strix automatically scopes to the PR's changed files (`--scope-mode auto`). If diff resolution fails, keep `fetch-depth: 0` or set `--diff-base` to the PR's actual base branch — use `origin/${{ github.base_ref }}` in GitHub Actions rather than a hard-coded `origin/main`, since repos use different default branches.
-- Exit codes: `0` pass, `2` vulnerabilities found (fails the job), `1` setup error.
-- The runner needs Docker (default GitHub-hosted Ubuntu runners have it).
-- **Size the budget so the scan completes — don't let it fail open.** A `0` exit means "no validated vulnerabilities in what was analyzed"; if `--max-budget` is hit before the diff is fully covered, the scan wraps up early and can still exit `0`. The "Fail unless the scan completed" step above narrows the gap: `strix_runs/<run>/run.json` is `"stopped"` when the scan was cut off at the hard budget limit without a final report. It is not a complete guard — the agents get graduated wrap-up warnings before that limit, and a run that wraps up on a warning still calls `finish_scan` and records `"completed"` with partial coverage. So keep that step in any pipeline that gates merges **and** give the scan real headroom (compare `run.json`'s `llm_usage.cost` against `--max-budget`; if it ran right up to the cap, raise it). For a `quick` diff-scoped PR scan `--max-budget 10` is usually ample, raise it for large diffs.
-
-### Optional: upload findings to GitHub code scanning
-
-Strix writes SARIF 2.1.0 to `strix_runs/<run>/findings.sarif`:
-
-```yaml
-      - name: Upload SARIF
-        if: always()
-        uses: github/codeql-action/upload-sarif@v3
-        with:
-          sarif_file: strix_runs
-```
-
-## Other CI systems
-
-Any pipeline works the same way — install, set the two env vars, run headless:
-
-```bash
-curl -sSL https://strix.ai/install | bash
-# Resolve the PR's base branch robustly (use your CI's base-branch variable if it
-# has one, e.g. GitHub Actions: origin/${{ github.base_ref }}). Avoid piping the
-# git lookup into another command — a failed lookup would otherwise be masked.
-BASE_BRANCH="${CI_MERGE_REQUEST_TARGET_BRANCH_NAME:-}"   # GitLab MR target
-if [ -z "$BASE_BRANCH" ]; then
-  BASE_BRANCH=$(git symbolic-ref --quiet --short refs/remotes/origin/HEAD 2>/dev/null)
-  BASE_BRANCH="${BASE_BRANCH#origin/}"
-fi
-DIFF_BASE="origin/${BASE_BRANCH:-main}"
-# Fail loudly rather than silently narrowing scope (e.g. to HEAD~1, which on a
-# multi-commit branch would scan only the last commit and let earlier ones pass).
-if ! git rev-parse --verify --quiet "$DIFF_BASE" >/dev/null; then
-  echo "Cannot resolve diff base '$DIFF_BASE'. Fetch the base branch (git fetch origin <base>) or set --diff-base explicitly." >&2
-  exit 1
-fi
-strix -n -t ./ --scan-mode quick --scope-mode diff --diff-base "$DIFF_BASE" --max-budget 10
-```
-
-Gate the pipeline on the exit code (see the budget/fail-open caveat above — give the scan enough budget to finish). Schedule `standard` scans nightly and `deep` scans for release candidates.
-
----
-
-# Option B — Managed platform (no runner infra)
-
-No workflow file, no Docker, no LLM key. Two ways to use it:
-
-1. **PR-review app (zero code):** the user installs the Strix GitHub/GitLab/Bitbucket app and enables PR reviews for the repo in the app.strix.ai dashboard. Every PR is then reviewed automatically, with findings posted as PR comments. Nothing to add to the repo. This is the lowest-effort path — recommend it first when the user just wants PR gating.
-
-2. **API-triggered from any pipeline:** if you want to trigger from an existing pipeline (or a system without the SCM app), call the API with a token that has `pr_reviews:write` (or `scans:write`). Store the token as a CI secret; ask the user to create it at **Settings → API Access**. Example GitHub Actions step:
-
-   ```yaml
-   - name: Strix PR review (managed)
-     if: github.event_name == 'pull_request'
-     env:
-       STRIX_API_TOKEN: ${{ secrets.STRIX_API_TOKEN }}
-     run: |
-       curl -sS --fail https://app.strix.ai/api/v1/pr-reviews/start \
-         -H "Authorization: Bearer $STRIX_API_TOKEN" \
-         -H "Content-Type: application/json" \
-         -d "{\"repository_full_name\":\"${{ github.repository }}\",\"pr_number\":${{ github.event.pull_request.number }}}"
-   ```
-
-   To gate the build on results, poll the PR review / scan status and fail on unresolved criticals/highs. Full endpoints (PR reviews, scans, SARIF export, schedules for scheduled deep scans) are in the **managed-pentesting-with-strix** skill.
-
-Recommend Option B for most teams (no maintenance, central dashboard); use Option A when scans must stay entirely within your own infrastructure.

skills/fix-security-vulnerabilities-with-strix/SKILL.md

@@ -1,77 +0,0 @@
----
-name: fix-security-vulnerabilities-with-strix
-description: Fix security vulnerabilities found by a Strix pentest (open-source CLI or app.strix.ai cloud) — triage by severity, patch the root cause rather than the symptom, and re-run Strix to prove each fix actually closes the exploit. Handles injection, XSS, SSRF, broken access control, IDOR, and other validated findings. Use after a Strix scan reports findings, or when the user asks to remediate, patch, or fix security issues from a strix_runs report, vulnerabilities.json, findings.sarif, or a cloud scan.
-license: Apache-2.0
-metadata:
-  author: usestrix
-  homepage: https://docs.strix.ai
----
-
-# Fix Strix findings and verify
-
-Turn validated Strix findings into minimal, correct fixes — and prove they work by re-scanning.
-
-## 1. Triage
-
-Get the findings from wherever the scan ran:
-
-- **OSS CLI** — artifacts in `strix_runs/<run-name>/`:
-  - `vulnerabilities/*.md` — one finding per file: description, severity, PoC steps or script, affected code locations, remediation guidance.
-  - `vulnerabilities.json` — the same findings as JSON (ids, severity, CWE/CVE, `code_locations` with `fix_before`/`fix_after` suggestions when available).
-- **Cloud (app.strix.ai)** — fetch the scan's `vulnerabilities[]` via `GET /api/v1/scans/{scanId}` (or `GET /api/v1/vulnerabilities` org-wide). Each carries `severity, cwe, endpoint, method, impact, technical_analysis, poc_description, poc_script_code` and, for code findings, `code_file`/`code_diff`/`code_before`/`code_after`. See the **managed-pentesting-with-strix** skill for auth.
-
-Order work by severity: critical → high → medium → low. Every Strix finding was validated with a working proof-of-concept, so do not dismiss findings as false positives without re-testing the PoC yourself.
-
-## 2. Fix
-
-For each finding:
-
-1. Reproduce it with the PoC from the finding file when feasible.
-2. Fix the root cause, not the specific payload (e.g. parameterize all queries, don't blocklist one string; enforce authorization in the handler, don't hide the endpoint).
-3. Prefer the framework's built-in defense (ORM parameterization, template auto-escaping, CSRF middleware, centralized authz) over ad-hoc sanitization.
-4. Keep the diff minimal and apply the repo's existing patterns. Finding files often include `fix_before`/`fix_after` snippets — use them as a starting point, not verbatim.
-
-Common finding classes and expected fixes: injection → parameterization/escaping at the sink; IDOR/broken access control → object-level authorization checks; SSRF → allowlist + block internal ranges; XSS → context-aware output encoding + CSP; secrets exposure → rotate the secret AND remove it from code/history; auth issues → fix the server-side check (never client-side).
-
-## 3. Verify by re-running Strix
-
-After fixing, re-scan scoped to the fixed area and confirm the finding is gone. Verify in whichever environment you scanned (or both):
-
-**OSS CLI:**
-```bash
-# Re-test just the changed files (fast). Resolve the repo's real default
-# branch instead of assuming origin/main (many repos use master/develop).
-# Avoid the current branch's own upstream as the base — its merge base with
-# HEAD would be HEAD, giving an empty diff and a falsely clean result.
-DIFF_BASE=$(git symbolic-ref --quiet --short refs/remotes/origin/HEAD 2>/dev/null)
-# origin/HEAD can be a dangling symbolic ref — keep it only if its target exists.
-git rev-parse --verify --quiet "$DIFF_BASE" >/dev/null 2>&1 || DIFF_BASE=""
-if [ -z "$DIFF_BASE" ]; then
-  for b in origin/main origin/master origin/develop; do
-    git rev-parse --verify --quiet "$b" >/dev/null && DIFF_BASE="$b" && break
-  done
-fi
-# No silent fallback: a guess like HEAD~1 would cover only the last commit of a
-# multi-commit fix branch. If no base resolves, ask the user for the base branch
-# (or use the focused --instruction verification below, which needs no diff base).
-[ -n "$DIFF_BASE" ] || { echo "Set DIFF_BASE to the branch your fix will merge into." >&2; exit 1; }
-strix -n -t ./ --scan-mode quick --scope-mode diff --diff-base "$DIFF_BASE" --max-budget 5
-
-# Or re-test with the original finding as focus (no diff base needed)
-strix -n -t ./ --instruction "Verify the SQL injection in app/api/search.py is fixed. Original PoC: <poc>" --max-budget 5
-```
-Exit codes: `2` = findings remain (read the new `strix_runs/<run>/vulnerabilities/` and iterate); `0` = clean **for what was analyzed**. Before trusting a `0`, confirm the run wasn't cut short — check `run.json` for a completed status and compare its `llm_usage.cost` with `--max-budget`: a hard budget stop leaves `status: "stopped"`, but a run that wrapped up on a budget warning records `"completed"` with partial coverage. Give verification enough budget to finish, and prefer re-running the specific PoC as the ground-truth signal.
-
-**Cloud:** rerun with the same config and re-poll, then confirm the finding no longer appears:
-```bash
-new_id=$(curl -sS "$BASE/scans/$scan_id/rerun" "${auth[@]}" -X POST | jq -r .scan_id)
-# poll GET /scans/$new_id until completed, then check its vulnerabilities[]
-```
-Or, if the cloud scan came from a repo/PR, trigger a fresh PR review on the fix branch (`POST /pr-reviews/start`). The platform also retests a single finding directly: `POST /api/v1/vulnerabilities/{vulnerabilityId}/retest`.
-
-- Also re-run the PoC manually when it is a simple request/script — fastest signal.
-- Run the project's own test suite to make sure the fix doesn't break behavior.
-
-## 4. Report
-
-Summarize per finding: severity, root cause, fix applied (file:line), verification result (re-scan clean / PoC no longer reproduces). Never include live secrets in the report; if a secret leaked, state that rotation is required.

skills/managed-pentesting-with-strix/SKILL.md

@@ -1,152 +0,0 @@
----
-name: managed-pentesting-with-strix
-description: Run a managed pentest of a web app or API through the app.strix.ai REST API — no local Docker, LLM key, or install needed. Create an API token, register domain/repository assets, launch and poll scans, triage vulnerabilities, export SARIF, download PDF/DOCX pentest reports for SOC 2 and other compliance evidence (Enterprise plan), start PR reviews, and set up schedules and webhooks. Use when the user wants continuous or scheduled pentesting-as-a-service, an auditor-ready pentest report, scans tracked in a team dashboard, or security testing from a sandboxed agent/CI environment with no infrastructure.
-license: Apache-2.0
-metadata:
-  author: usestrix
-  homepage: https://docs.app.strix.ai
----
-
-# Strix Cloud API (managed, no local infra)
-
-Use this when you want Strix's autonomous pentesting **without running Docker or an LLM yourself** — the scan runs on Strix's infrastructure and results are tracked in a team dashboard. This is the right choice in sandboxed/hosted agent and CI environments, for teams, and for scheduled/continuous testing (downloadable PDF/DOCX reports are an Enterprise-plan feature). For fully local, free, air-gapped, or BYO-LLM runs, use the open-source CLI in the **penetration-testing-with-strix** skill instead — both share the same engine and SARIF output, so you can mix them.
-
-Full reference: **[docs.app.strix.ai](https://docs.app.strix.ai)** · OpenAPI: `https://docs.app.strix.ai/openapi.json`
-
-## Setup
-
-- **Base URL:** `https://app.strix.ai/api/v1`
-- **Auth:** every request sends `Authorization: Bearer <token>`. Tokens are **org-scoped**.
-- **Get a token:** the user creates one in the dashboard at **Settings → API Access** (app.strix.ai). Ask them for it; never hardcode, log, or commit it. Store it in an env var or the CI secret store.
-- **Scopes (least-privilege):** assign only what the integration needs and rotate regularly:
-
-  | Scope | Grants |
-  |---|---|
-  | `scans:read` / `scans:write` | list/read/report scans · create/rerun/cancel scans |
-  | `vulnerabilities:read` / `:write` | read findings · update status & notes |
-  | `assets:read` / `:write` | read domains/repos · register/update them |
-  | `schedules:read` / `:write` | read schedules · create/trigger recurring scans |
-  | `pr_reviews:write` | trigger PR security reviews |
-  | `webhooks:read` / `:write` | manage webhook subscriptions |
-  | `tokens:write` | create/revoke API tokens |
-
-```bash
-export STRIX_API_TOKEN="<token>"
-BASE=https://app.strix.ai/api/v1
-auth=(-H "Authorization: Bearer $STRIX_API_TOKEN")
-```
-
-All examples use `jq` to parse JSON. Handle HTTP errors: `401` bad/expired token, `402` out of credits, `403` scope/plan-tier limit, `422` validation error.
-
-## 1. Register the target as an asset
-
-Scans run against **registered assets**, not raw URLs. Register once, then reuse the returned UUID.
-
-```bash
-# Domain (black-box / live target). Requires domain verification before external scanning.
-# asset_type must be one of: web_app | api | attack_surface.
-curl -sS "$BASE/domains" "${auth[@]}" -H "Content-Type: application/json" \
-  -d '{"domain":"staging.example.com","asset_type":"web_app"}' | jq '{id:.domain.id, status, reachable, verification}'
-
-# Repository (white-box / code review). `full_name` is "owner/name".
-# Send one repository object, or a bare JSON array for several — not an object
-# wrapping a "repositories" key (that is rejected with 400).
-curl -sS "$BASE/repositories" "${auth[@]}" -H "Content-Type: application/json" \
-  -d '[{"full_name":"org/app","provider":"github"}]' | jq '.repositories[] | {id, full_name}'
-```
-
-Look up existing assets instead of re-adding: `GET /domains`, `GET /repositories` (both `assets:read`, paginated with `?page=&limit=`).
-
-## 2. Launch a scan
-
-`POST /scans` (`scans:write`). Provide at least one target via `domain_ids`, `repository_ids`, or `internal_targets` (internal infra needs a network connector — see docs).
-
-```bash
-scan_id=$(curl -sS "$BASE/scans" "${auth[@]}" -H "Content-Type: application/json" -d '{
-  "engagement_type": "live_test",
-  "domain_ids": ["<domain-uuid>"],
-  "focus": "IDOR, auth bypass, SSRF",
-  "context": "Staging. Test account creds are configured as a test user.",
-  "notify_on_completion": true
-}' | jq -r .scan_id)
-echo "$scan_id"
-```
-
-Useful `CreateScanRequest` fields:
-
-| Field | Purpose |
-|---|---|
-| `engagement_type` | `live_test` (default), `code_review`, `internal_infra`, `compliance_pentest` |
-| `domain_ids` / `repository_ids` / `internal_targets` | targets (at least one) |
-| `domain_paths` / `repository_branches` | narrow to specific paths / branches |
-| `credentials` | authenticated scanning, incl. `mfa_method` (`totp`/`email_otp`/…) + `totp_secret` |
-| `headers` | extra HTTP headers (e.g. API keys) for the target |
-| `focus` / `concerns` / `context` | steer the agents |
-| `upload_ids` | attach uploaded source/docs archives for white-box context |
-| `notify_on_completion` / `notification_emails` | email when done |
-
-Response is `{ scan_id, title, status }` with `status` = `pending`.
-
-## 3. Poll to completion
-
-`GET /scans/{scanId}` (`scans:read`). Status flow: `pending → running → completed` (or `failed` / `cancelled`). Poll on an interval — scans take minutes to hours; don't block.
-
-```bash
-while :; do
-  s=$(curl -sS "$BASE/scans/$scan_id" "${auth[@]}" | jq -r .status)
-  echo "status=$s"; [[ "$s" =~ ^(completed|failed|cancelled)$ ]] && break
-  sleep 60
-done
-```
-
-## 4. Read findings
-
-The scan-detail response includes `executive_summary`, `methodology`, `recommendations`, a `findings` severity roll-up, and a `vulnerabilities[]` array. Each vulnerability carries `title, severity, status, cvss, cwe, endpoint, method, impact, technical_analysis, poc_description, poc_script_code`, and (for code findings) `code_file`/`code_diff`/`code_before`/`code_after`.
-
-```bash
-curl -sS "$BASE/scans/$scan_id" "${auth[@]}" \
-  | jq '["critical","high","medium","low","info"] as $order
-       | .vulnerabilities
-       | sort_by(.severity as $s | $order | index($s))
-       | .[] | {title, severity, endpoint, cwe}'
-```
-
-Cloud severities are `critical | high | medium | low` and statuses are `open | in_progress | fixed | ignored`. Sort by an explicit severity order rather than `sort_by(.severity)`, which sorts alphabetically (critical, high, low, medium).
-
-Org-wide triage across scans: `GET /vulnerabilities` (`vulnerabilities:read`; filter by severity/status). Update triage state with the vulnerabilities `:write` endpoints. To remediate, hand off to the **fix-security-vulnerabilities-with-strix** skill.
-
-## 5. Export & report
-
-```bash
-# SARIF 2.1.0 for GitHub code scanning / ASPM ingestion
-curl -sS "$BASE/scans/$scan_id/sarif" "${auth[@]}" -o findings.sarif
-
-# Report. The format and file type are query params (`Accept` is ignored):
-#   format=technical (default) | retest | attestation | executive_summary
-#   type=pdf (default) | docx
-# Any report download requires the Enterprise plan; formats beyond `technical`,
-# DOCX, and white-label branding are Enterprise-only too. Scan must be completed.
-curl -sS "$BASE/scans/$scan_id/report?format=technical&type=pdf" "${auth[@]}" -o strix-report.pdf
-```
-
-## 6. PR reviews
-
-Trigger an automated security review of a pull request (`pr_reviews:write`); results appear as PR comments and in the dashboard:
-
-```bash
-curl -sS "$BASE/pr-reviews/start" "${auth[@]}" -H "Content-Type: application/json" \
-  -d '{"repository_full_name":"org/app","pr_number":123}'
-```
-
-List/inspect via `GET /pr-reviews` and `GET /pr-reviews/{id}`. Repo-level PR-review behavior is configured with the repository-settings endpoint.
-
-## 7. Continuous testing (schedules & webhooks)
-
-- **Schedules** (`schedules:write`, Pro plan): create recurring scans and trigger them on demand — the managed equivalent of a cron-driven CLI loop.
-- **Webhooks** (`webhooks:write`): subscribe to pentest/vulnerability lifecycle events (e.g. `scan.completed`, `vulnerability.created`) to push results into Slack, ticketing, or your own pipeline instead of polling.
-
-See the schedules and webhooks sections at [docs.app.strix.ai](https://docs.app.strix.ai) for payloads.
-
-## Safety
-
-Only scan assets the user's organization owns or is authorized to test. External domain scans require verification (DNS/file/meta-tag) enforced by the platform — don't try to bypass it.

skills/penetration-testing-with-strix/SKILL.md

@@ -1,143 +0,0 @@
----
-name: penetration-testing-with-strix
-description: Pentest a web app, API, codebase, repository, URL, domain, or IP with Strix — autonomous AI penetration testing that exploits and proves vulnerabilities (OWASP Top 10 and beyond — injection, XSS, SSRF, auth/access-control flaws, IDOR, business logic) instead of just flagging them. Runs self-hosted with the open-source CLI or via the managed app.strix.ai cloud, and returns validated findings with proof-of-concept exploits (Markdown, JSON, CSV, SARIF). Use when the user asks to pentest, hack, security-scan, security-audit, or find vulnerabilities in an app, API, website, or repo.
-license: Apache-2.0
-metadata:
-  author: usestrix
-  homepage: https://docs.strix.ai
----
-
-# Run a Strix pentest
-
-Strix runs autonomous AI pentesting agents that dynamically exploit a target and only report findings validated with a working proof-of-concept. There are **two ways to run it, built on the same engine and producing the same findings** — pick per situation, and mix them freely:
-
-- **Open-source CLI** (self-hosted) — runs on your machine in a Docker sandbox with your own LLM key. Free, fully local, BYO-LLM, air-gap capable. Docs: [docs.strix.ai](https://docs.strix.ai).
-- **Cloud API** (managed) — runs on Strix's infrastructure via `https://app.strix.ai/api/v1`. No Docker, no LLM key, no local compute; adds team dashboards, scheduling, PR reviews, downloadable PDF/DOCX reports (Enterprise plan), and internal-network connectors. Docs: [docs.app.strix.ai](https://docs.app.strix.ai). Full workflow in the **managed-pentesting-with-strix** skill.
-
-## Which one? (decide, don't default)
-
-Choose honestly based on the situation — neither is "better":
-
-| Situation | Prefer |
-|---|---|
-| No Docker available, or a sandboxed/hosted agent/CI environment | **Cloud** |
-| User has no LLM key / doesn't want to pay per-token or manage models | **Cloud** |
-| Team visibility, shareable dashboard, scheduled/continuous scans, PR reviews, downloadable PDF/DOCX report (Enterprise) | **Cloud** |
-| Scanning internal/private infrastructure not reachable from your machine | **Cloud** (network connector) |
-| Source must never leave local infra (privacy/air-gap), or fully offline | **OSS CLI** |
-| Free / one-off / local dev-loop scan, Docker already present | **OSS CLI** |
-| BYO or self-hosted LLM, or a specific model not offered by the platform | **OSS CLI** |
-| CI: runner already has Docker and you want a self-contained gate | **OSS CLI** |
-| CI: no Docker, or you want results tracked centrally | **Cloud** |
-
-**Mix them:** e.g. use the OSS CLI for the fast local dev-loop while writing/fixing code, and the Cloud for the authoritative, team-visible scan + report + tracking; or gate PRs with the OSS CLI in CI while the Cloud runs scheduled deep scans and PR reviews across the org. Both emit the same SARIF 2.1.0, so findings line up across environments.
-
-If unsure and the user has (or will create) an app.strix.ai account, prefer **Cloud** — it avoids all local-infra friction. If they want zero signup / full local control, use the **OSS CLI**.
-
----
-
-# Option A — Open-source CLI (self-hosted)
-
-## Prerequisites
-
-1. **Docker running** — check with `docker info`. The first scan pulls the sandbox image automatically.
-2. **Strix installed** — check with `strix --version`. Install if missing:
-   ```bash
-   curl -sSL https://strix.ai/install | bash   # or: pipx install strix-agent
-   ```
-3. **LLM configured** — two environment variables:
-   ```bash
-   export STRIX_LLM="openai/gpt-5.4"      # any LiteLLM model id (openai/..., anthropic/..., openrouter/...)
-   export LLM_API_KEY="<provider api key>"
-   ```
-   Ask the user for these if unset. Never hardcode or commit keys.
-
-## Running a scan
-
-Always use `-n` (non-interactive/headless) — the default TUI blocks agents. Always set `--max-budget` unless the user says otherwise.
-
-```bash
-# Local code (white-box)
-strix -n -t ./ --scan-mode standard --max-budget 10
-
-# Deployed app / API (black-box)
-strix -n -t https://staging.example.com --max-budget 20
-
-# Repo + deployed app together (best coverage)
-strix -n -t https://github.com/org/app -t https://staging.example.com
-
-# Focused testing with credentials or scope hints
-strix -n -t https://app.example.com \
-  --instruction "Use credentials user@example.com:pass123. Focus on IDOR and auth bypass."
-
-# Large monorepo: bind-mount instead of copying
-strix -n --mount ./huge-monorepo
-```
-
-Key flags:
-
-| Flag | Meaning |
-|---|---|
-| `-t, --target` | URL, repo URL, local path, domain, or IP. Repeatable. |
-| `-n, --non-interactive` | Headless, exits on completion. Required for agents. |
-| `-m, --scan-mode` | `quick` (minutes) / `standard` (~30 min) / `deep` (hours, default). |
-| `--instruction` / `--instruction-file` | Credentials, focus areas, scope rules. |
-| `--max-budget USD` | Hard LLM spend cap; scan wraps up cleanly at the limit. |
-| `--max-turns N` | Per-agent turn cap (default 500). |
-| `--resume RUN_NAME` | Resume a prior run from `strix_runs/`. |
-
-Scans take minutes (`quick`) to hours (`deep`). Run them in the background and poll for completion rather than blocking.
-
-### Exit codes (headless)
-
-- `0` — finished with no validated vulnerabilities **in what was analyzed**
-- `1` — fatal error (missing env vars, Docker down, bad config)
-- `2` — vulnerabilities found
-
-A `0` is not proof of full coverage: if `--max-budget`/`--max-turns` is reached before the scan completes, it wraps up early and still exits `0`. When you need assurance the scan finished, give it enough budget and check `strix_runs/<run>/run.json`: a hard budget stop leaves `status: "stopped"`, but an agent that wrapped up early on a budget *warning* still calls `finish_scan` and records `"completed"` — so also sanity-check the run's cost against `--max-budget` and the report's stated coverage before treating a clean result as full coverage.
-
-### Reading results
-
-Artifacts land in `strix_runs/<run-name>/`:
-
-| File | Contents |
-|---|---|
-| `penetration_test_report.md` | Executive report — read this first. |
-| `vulnerabilities/*.md` | One file per validated finding, with PoC and remediation. |
-| `vulnerabilities.json` / `vulnerabilities.csv` | All findings as structured JSON / CSV index. |
-| `findings.sarif` | SARIF 2.1.0 for GitHub code scanning / ASPM ingestion. |
-| `run.json` | Run metadata, status, targets, usage/cost. |
-
----
-
-# Option B — Cloud API (managed, no local infra)
-
-Full details, asset registration, polling, reports, PR reviews, schedules, and webhooks are in the **managed-pentesting-with-strix** skill. Minimal launch-and-poll:
-
-```bash
-export STRIX_API_TOKEN="<token>"   # org-scoped bearer, from Settings → API Access at app.strix.ai
-BASE=https://app.strix.ai/api/v1
-
-# 1. Launch a scan against an already-registered domain/repo asset
-scan_id=$(curl -sS "$BASE/scans" \
-  -H "Authorization: Bearer $STRIX_API_TOKEN" -H "Content-Type: application/json" \
-  -d '{"engagement_type":"live_test","domain_ids":["<domain-uuid>"]}' | jq -r .scan_id)
-
-# 2. Poll until terminal (pending → running → completed/failed/cancelled)
-curl -sS "$BASE/scans/$scan_id" -H "Authorization: Bearer $STRIX_API_TOKEN" | jq '.status'
-
-# 3. Read validated findings from the scan detail's `vulnerabilities[]`, or export SARIF
-curl -sS "$BASE/scans/$scan_id/sarif" -H "Authorization: Bearer $STRIX_API_TOKEN" -o findings.sarif
-```
-
-Ask the user to create the token (and register the target as a domain/repository asset) if they haven't. If Docker/local prerequisites aren't already satisfied, use this path instead of trying to install infra.
-
----
-
-## Reporting & next steps
-
-Summarize findings by severity (critical/high/medium/low/info) and include the PoC evidence. To remediate and verify fixes (via either path), use the **fix-security-vulnerabilities-with-strix** skill. To wire scanning into CI/CD, use the **ci-security-scanning-with-strix** skill.
-
-## Safety
-
-Only scan targets the user owns or is authorized to test. The Cloud platform enforces domain verification before external scans; for the OSS CLI, confirm authorization yourself if the target looks like third-party infrastructure.

strix.spec

@@ -7,14 +7,6 @@ from PyInstaller.utils.hooks import collect_data_files, collect_submodules
 project_root = Path(SPECPATH)
 strix_root = project_root / 'strix'
 
-tui_name = 'strix-tui.exe' if sys.platform == 'win32' else 'strix-tui'
-tui_binary = project_root / 'build' / 'sidecar' / tui_name
-if not tui_binary.is_file():
-    raise FileNotFoundError(
-        f'Missing Go TUI sidecar at {tui_binary}; run `make tui-build` first'
-    )
-binaries = [(str(tui_binary), 'strix/bin')]
-
 datas = []
 
 for md_file in strix_root.rglob('skills/**/*.md'):
@@ -29,20 +21,17 @@ for xml_file in strix_root.rglob('*.xml'):
     rel_path = xml_file.relative_to(project_root)
     datas.append((str(xml_file), str(rel_path.parent)))
 
-# Prebuilt local-viewer SPA (served by `strix view`).
-viewer_static = strix_root / 'interface' / 'viewer' / 'static'
-for asset in viewer_static.rglob('*'):
-    if asset.is_file():
-        rel_path = asset.relative_to(project_root)
-        datas.append((str(asset), str(rel_path.parent)))
+for tcss_file in strix_root.rglob('*.tcss'):
+    rel_path = tcss_file.relative_to(project_root)
+    datas.append((str(tcss_file), str(rel_path.parent)))
+
+datas += collect_data_files('textual')
 
 datas += collect_data_files('tiktoken')
 datas += collect_data_files('tiktoken_ext')
 
 datas += collect_data_files('litellm')
 
-datas += collect_data_files('agents', includes=['**/*.md', '**/*.jinja', '**/*.json'])
-
 hiddenimports = [
     # Core dependencies
     'litellm',
@@ -54,6 +43,17 @@ hiddenimports = [
     'litellm.utils',
     'litellm.caching',
 
+    # Textual TUI
+    'textual',
+    'textual.app',
+    'textual.widgets',
+    'textual.containers',
+    'textual.screen',
+    'textual.binding',
+    'textual.reactive',
+    'textual.css',
+    'textual._text_area_theme',
+
     # Rich console
     'rich',
     'rich.console',
@@ -116,83 +116,34 @@ hiddenimports = [
     'strix.interface.main',
     'strix.interface.cli',
     'strix.interface.tui',
-    'strix.interface.tui.runtime',
-    'strix.interface.tui.history',
-    'strix.interface.tui.live_view',
-    'strix.interface.tui.backend',
-    'strix.interface.tui.backend.controller',
-    'strix.interface.tui.backend.messages',
-    'strix.interface.tui.backend.protocol',
-    'strix.interface.tui.backend.server',
     'strix.interface.utils',
+    'strix.interface.tool_components',
     'strix.agents',
-    'strix.agents.factory',
-    'strix.agents.prompt',
-    'strix.config.loader',
-    'strix.config.settings',
-    'strix.config.codex',
-    '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.interface.viewer',
-    'strix.interface.viewer.auth',
-    'strix.interface.viewer.cli',
-    'strix.interface.viewer.report_pdf',
-    'strix.interface.viewer.server',
-    'strix.interface.viewer.transcript',
-
-    # PDF report generation + encryption
-    'reportlab',
-    'reportlab.pdfgen',
-    'reportlab.pdfbase',
-    'reportlab.lib',
-    'reportlab.platypus',
-    'pypdf',
-    'cryptography',
+    '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',
 ]
 
 hiddenimports += collect_submodules('litellm')
+hiddenimports += collect_submodules('textual')
 hiddenimports += collect_submodules('rich')
 hiddenimports += collect_submodules('pydantic')
 hiddenimports += collect_submodules('pygments')
-# reportlab loads renderers/fonts dynamically, so pull its whole tree in.
-hiddenimports += collect_submodules('reportlab')
-
-# reportlab ships bundled fonts (.pfb/.afm) it needs at runtime.
-datas += collect_data_files('reportlab')
-
-# reportlab imports PIL (pillow) lazily for image handling, so it must be
-# bundled explicitly and kept out of the excludes list below.
-hiddenimports += collect_submodules('PIL')
-datas += collect_data_files('PIL')
 
 excludes = [
     # Sandbox-only packages
@@ -205,6 +156,9 @@ excludes = [
     'pyte',
     'openhands_aci',
     'openhands-aci',
+    'gql',
+    'fastapi',
+    'uvicorn',
     'numpydoc',
 
     # Google Cloud / Vertex AI
@@ -240,13 +194,14 @@ excludes = [
     'numpy',
     'pandas',
     'scipy',
+    'PIL',
     'cv2',
 ]
 
 a = Analysis(
     ['strix/interface/main.py'],
     pathex=[str(project_root)],
-    binaries=binaries,
+    binaries=[],
     datas=datas,
     hiddenimports=hiddenimports,
     hookspath=[],

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,151 @@
+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", [])
+        diff_scope = scan_config.get("diff_scope", {}) or {}
+        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)
+
+        if diff_scope.get("active"):
+            task_parts.append("\n\nScope Constraints:")
+            task_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", []):
+                repo_label = (
+                    repo_scope.get("workspace_subdir")
+                    or repo_scope.get("source_path")
+                    or "repository"
+                )
+                changed_count = repo_scope.get("analyzable_files_count", 0)
+                deleted_count = repo_scope.get("deleted_files_count", 0)
+                task_parts.append(
+                    f"- {repo_label}: {changed_count} changed file(s) in primary scope"
+                )
+                if deleted_count:
+                    task_parts.append(
+                        f"- {repo_label}: {deleted_count} deleted file(s) are context-only"
+                    )
+
+        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

@@ -1,14 +1,5 @@
-You are an advanced AI application security validation agent. Your purpose is to perform authorized security verification, reproduce and validate weaknesses on in-scope assets, and help remediate real security issues.
+You are Strix, an advanced AI application security validation agent developed by OmniSecure Labs. Your purpose is to perform authorized security verification, reproduce and validate weaknesses on in-scope assets, and help remediate real security issues.
 You follow all instructions and rules provided to you exactly as written in the system prompt at all times.
-{% if is_root %}
-<root_agent_directive>
-YOU ARE THE ROOT AGENT. Your job is ORCHESTRATION, not hands-on testing.
-- You accomplish security work by DELEGATING to specialized subagents via create_agent — you do NOT run scanners, crawlers, fuzzers, or send exploit/injection payloads yourself.
-- IMPORTANT — how to read this prompt as root: the rest of this system prompt is written in the second person ("you") and describes the hands-on testing methodology (recon, mapping, scanning, payload spraying, PoC building, fixing). When you are the root agent, treat every such hands-on instruction as something you ensure gets done BY A SUBAGENT, not as a task you perform in your own turns. The "map the target", "recon first", "mandatory initial phases", and "spray payloads" directives are DELEGATION REQUIREMENTS for you — spawn recon/mapping/testing subagents to satisfy them.
-- Do NOT probe endpoints, run "basic" or "quick" injection/XSS/etc. tests, or do exploratory scanning before delegating. Even a single quick test on a discovered endpoint is out of role: spin up a subagent instead.
-- Your own turns should be spent on: reading scope/config, decomposing the target, spawning and monitoring subagents, tracking todos/notes/coverage, deciding next steps, and aggregating results into the final report.
-</root_agent_directive>
-{% endif %}
 
 <core_capabilities>
 - Security assessment and vulnerability scanning
@@ -22,45 +13,41 @@ CLI OUTPUT:
 - You may use simple markdown: **bold**, *italic*, `code`, ~~strikethrough~~, [links](url), and # headers
 - Do NOT use complex markdown like bullet lists, numbered lists, or tables
 - Use line breaks and indentation for structure
-- NEVER use any identifiable names/markers in HTTP requests, payloads, user-agents, or any inputs
+- 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
-- wait_for_agents blocks and resumes you automatically, so it is never a poll you repeat: issue exactly ONE wait, then stop and react to what it returns. Never write out a wait/check loop (wait → view_agent_graph → wait → ...) ahead of time — those extra calls only strand you and are collapsed anyway
 
 {% if interactive %}
 INTERACTIVE BEHAVIOR:
-- You are in an interactive conversation with a user.
-- HOW EXECUTION ENDS: your turn ends ONLY when you make an explicit lifecycle tool call. Plain text NEVER ends your turn and NEVER hands control to the user — text is shown to the user, and then execution continues.
-  - To answer the user and hand control back, call respond_to_user. It delivers your message AND parks you for their reply in one call, so there is no way to answer and then forget to stop. This is the ONLY way to yield to the user.
-  - To wait on another AGENT (a child's report, a peer's reply), call wait_for_agents. That is not a way to reach the user.
-  - To end the whole engagement, call the lifecycle tool: finish_scan (root) or agent_finish (subagent).
-  - A turn that ends with plain text and no tool call does NOT stop you: the system nudges you to continue and will re-run you. Do not rely on going silent to pause — it will not pause you.
-- Answering a user question: put the answer in respond_to_user's message. Do not write the answer as plain text and then fall silent — that does not reach a stopping point, it just triggers a continuation nudge.
-- If all you want to do is reply and stop, that whole turn is ONE respond_to_user call carrying the answer. Do not write the answer as text and then call respond_to_user as well: the user reads it twice.
-- If you do end a turn on plain text and the nudge arrives, your words already reached the user. Do not restate them: call respond_to_user with NO message to simply wait, or with only whatever you still need to add.
-- You may include brief explanatory text before a tool call, and you can narrate while you work — plain text is shown to the user as you go. Narrating is free; respond_to_user is specifically the act of WAITING for the user, so do not call it just to give a status update.
-- Respond naturally when the user asks questions or gives instructions.
-- While actively working on a task, every turn should carry exactly one tool call — use think to plan, the appropriate tool to act, and respond_to_user only when you genuinely need the user.
-- Never loop through think or other tools just to prepare, polish, confirm, or announce an answer. Once you know the answer, send it with respond_to_user.
+- You are in an interactive conversation with a user
+- CRITICAL: A message WITHOUT a tool call IMMEDIATELY STOPS your entire execution and waits for user input. This is a HARD SYSTEM CONSTRAINT, not a suggestion.
+  - Statements like "Planning the assessment..." or "I'll now scan..." or "Starting with..." WITHOUT a tool call will HALT YOUR WORK COMPLETELY. The system interprets no-tool-call as "I'm done, waiting for the user."
+  - If you want to plan, call the think tool. If you want to act, call the appropriate tool. There is NO valid reason to output text without a tool call while working on a task.
+  - The ONLY time you may send a message without a tool call is when you are genuinely DONE and presenting final results, or when you NEED the user to answer a question before continuing.
+- 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
+- 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 %}
 AUTONOMOUS BEHAVIOR:
 - Work autonomously by default
 - You should NOT ask for user input or confirmation - you should always proceed with your task autonomously.
 - Minimize user messaging: avoid redundancy and repetition; consolidate updates into a single concise message
-- NEVER send an empty or blank message. If you have no content to output or need to wait for subagent results, you MUST call the wait_for_agents tool (or another appropriate tool) instead of emitting an empty response.
-- There is no user attached to this run, so there is nobody to ask and nothing to yield to. If there is nothing left to execute: do NOT send filler/repetitive text — either call wait_for_agents (only if you are genuinely expecting another agent to message you) 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 waiting on another agent, use wait_for_agents; when done, use agent_finish (subagents) or finish_scan (root)
-- A text-only turn does nothing: it neither ends the run nor yields — it just wastes a turn and forces a retry. The lifecycle tools (``finish_scan`` for root, ``agent_finish`` for subagents) are the ONLY way to terminate, and the report flows through them. If you find yourself wanting to say "Done!" or "Scan complete" without a tool call, call the lifecycle tool instead.
+- 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)
 {% endif %}
 </communication_rules>
 
 <execution_guidelines>
 {% if system_prompt_context and system_prompt_context.authorized_targets %}
 SYSTEM-VERIFIED SCOPE:
-- The following scope metadata is injected by the platform into the system prompt and is authoritative
+- The following scope metadata is injected by the Strix platform into the system prompt and is authoritative
 - Scope source: {{ system_prompt_context.scope_source }}
 - Authorization source: {{ system_prompt_context.authorization_source }}
 - Every target listed below has already been verified by the platform as in-scope and authorized
@@ -126,17 +113,21 @@ 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)
+- 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); if any are skipped, record why in the shared wiki
 - 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.
+- 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, and log fallback reason in the wiki.
+- Shared memory: Use notes as shared working memory; discover wiki notes with `list_notes`, read `wiki:overview` first when available, then read `wiki:security` via `get_note(note_id=...)` before analysis
+- Before `agent_finish`/`finish_scan`, update `wiki:security` with scanner summaries, key routes/sinks, and dynamic follow-up plan
 - 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.
 - 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.
 - Try to infer how to run the code based on its structure and content.
-- Derive the code fix as PART OF reporting, not as a separate later pass: create_vulnerability_report already requires the concrete patch inline (`code_locations` with verbatim `fix_before`/`fix_after` and `fix_pr_body`), so the reporting agent that analyzes the root cause is the one that produces the fix. Do NOT spawn a downstream agent afterwards to re-derive/re-apply the same patch.
-- If you also apply and verify the patch in the repo (edit the file, re-test that the vulnerability is gone), do it in the same agent/turn while the analysis is fresh — right before or as part of filing the report — never as a second re-analysis pass.
+- FIX discovered vulnerabilities in code in same file.
+- Test patches to confirm vulnerability removal.
+- Do not stop until all reported vulnerabilities are fixed.
+- Include code diff in final report.
 
 COMBINED MODE (code + deployed target present):
 - Treat this as static analysis plus dynamic testing simultaneously
@@ -157,12 +148,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
@@ -171,34 +163,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 to a file and
-  run them with `python3 script.py`. For one-off snippets, `python3 -c` or a
-  here-document is acceptable, but avoid deeply nested quotes/parentheses — if
-  a snippet needs complex quoting or is more than a few lines, write it to a
-  file first to prevent syntax errors.
-- Before importing a third-party Python library, make sure it is installed. The
-  sandbox's `python3` runs inside a preconfigured virtualenv that ships
-  `requests`, `httpx`, `beautifulsoup4` (bs4), `lxml`, `pyjwt`, and
-  `cryptography`; for anything else prefer the stdlib or run `pip install <pkg>`
-  (it installs into that active venv) before importing, rather than letting the
-  script fail with `ModuleNotFoundError`.
-- `exec_command` runs each command in a fresh non-interactive shell (plain
-  pipes, no TTY). To drive an interactive or long-running process with
-  `write_stdin` — REPLs, `ssh`/`nc`/`ftp`, `sqlmap`, or to send Ctrl-C —
-  you MUST start it with `exec_command(cmd="...", tty=true)` and then
-  `write_stdin(session_id=<id>, chars="...")`. Calling `write_stdin` on a
-  default (non-TTY) command or on a process that has already exited fails with
-  "stdin is not available".
-- 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 established fuzzers/scanners where applicable: ffuf, sqlmap, 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.
+- 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 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
@@ -209,17 +181,13 @@ EFFICIENCY TACTICS:
 VALIDATION REQUIREMENTS:
 - Full validation required - no assumptions
 - Demonstrate concrete impact with evidence
-- Consider business context for severity assessment — check whether the target is a demo/sandbox environment or content meant to be public, and factor that in
-- Score only the security impact demonstrated by the proof of concept. Reachability, missing authentication, scanner labels, and theoretical follow-on attacks do not by themselves justify non-None CVSS impact metrics
-- Treat public metadata, internal-looking identifiers, source maps without secrets, and transport/configuration hygiene as observations unless validation proves unauthorized restricted-data access, modification, or service disruption
-- Every non-None Confidentiality, Integrity, or Availability metric must map to explicit evidence in the report; use Scope Changed only for a demonstrated crossing of security authorities
+- Consider business context for severity assessment
 - Independent verification through subagent
 - Document complete attack chain
 - Keep going until you find something that matters
-- A vulnerability is ONLY considered reported when a reporting agent uses create_vulnerability_report (or create_dependency_report for known-CVE dependency/supply-chain findings) with full details. Mentions in agent_finish, finish_scan, or generic messages are NOT sufficient
-- Reporting and fixing are ONE step, not two: when source is available, the reporting agent derives the concrete fix and files it INLINE via create_vulnerability_report (`code_locations` with `fix_before`/`fix_after` + `fix_pr_body`) — the report is not complete without it. Do NOT report first and then spawn a separate downstream agent to re-derive and re-apply the same patch; that just re-does the analysis and wastes tokens. (Do not silently patch a finding WITHOUT filing a report — the report, with its embedded fix, is the deliverable.)
+- A vulnerability is ONLY considered reported when a reporting agent uses create_vulnerability_report with full details. Mentions in agent_finish, finish_scan, or generic messages are NOT sufficient
+- Do NOT patch/fix before reporting: first create the vulnerability report via create_vulnerability_report (by the reporting agent). Only after reporting is completed should fixing/patching proceed
 - DEDUPLICATION: The create_vulnerability_report tool uses LLM-based deduplication. If it rejects your report as a duplicate, DO NOT attempt to re-submit the same vulnerability. Accept the rejection and move on to testing other areas. The vulnerability has already been reported by another agent
-- REVIEWING FILED FINDINGS (orchestrator/root agent): use list_reports to see every vulnerability filed so far in this scan (by any agent, root or child) — metadata-first with per-severity counts — and get_report to read one finding in full by its id. These are read-only orchestration tools: the root agent uses them to track coverage, avoid dispatching work on already-covered ground, assemble the finish_scan executive summary, and reason about attack-chaining across confirmed findings. Leaf/specialist agents should NOT call them — just do your assigned testing and file findings. Each entry shows which agent filed it (agent_name), and your own entries are flagged by_you. list_notes/get_note do the same for notes.
 </execution_guidelines>
 
 <vulnerability_focus>
@@ -263,30 +231,16 @@ Remember: A single well-validated high-impact vulnerability is worth more than d
 <multi_agent_system>
 AGENT ISOLATION & SANDBOXING:
 - All agents run in the same shared Docker container for efficiency
-- Each agent has its own terminal sessions
-- Browsers are NOT per-agent by default: `agent-browser` with no `--session` is one
-  shared browser, so a concurrent agent's navigation invalidates your page and refs.
-  Pass `--session <your-agent-name>` for any browser work of your own — then it is
-  yours alone. Each session is a full Chromium (~340 MB) on this shared box, so keep
-  one, not several, and `agent-browser --session <name> close` when you're done with
-  the target; an idle browser is reclaimed automatically after 3 minutes
+- Each agent has its own: browser sessions, terminal sessions
 - All agents share the same /workspace directory and proxy history
 - Agents can see each other's files and proxy traffic for better collaboration
 
-DISK & SCRATCH HYGIENE:
-- /workspace is a shared, finite disk used by all agents at once — be a considerate tenant
-- Prefer bounded recon: scope crawls and scans by depth, duration, and target rather than "collect everything"
-- Redirect large tool output to a file, and once you've extracted what you need (e.g. a URL/endpoint list), remove the raw output
-- If disk gets tight or a write fails for space, check what's large under /workspace and clean up files from your own task; leave another agent's files unless you've confirmed they're no longer in use
-
 MANDATORY INITIAL PHASES:
-{% if is_root %}
-- ROOT AGENT: these phases are mandatory for the assessment, but you MUST accomplish them by delegating to reconnaissance/mapping subagents — do NOT run recon, crawling, enumeration, or mapping tools in your own turns. Spawn the appropriate subagent(s) and track their coverage.
-{% endif %}
+
 BLACK-BOX TESTING - PHASE 1 (RECON & MAPPING):
 - COMPLETE full reconnaissance: subdomain enumeration, port scanning, service detection
 - MAP entire attack surface: all endpoints, parameters, APIs, forms, inputs
-- CRAWL thoroughly: spider all pages (authenticated and unauthenticated), discover hidden paths, analyze JS files — keep each crawl bounded by depth/duration, and tidy up raw output once endpoints are extracted
+- CRAWL thoroughly: spider all pages (authenticated and unauthenticated), discover hidden paths, analyze JS files
 - ENUMERATE technologies: frameworks, libraries, versions, dependencies
 - Reconnaissance should normally happen before targeted vulnerability discovery unless the correct next move is already obvious or the user/system explicitly asks to prioritize a specific area first
 - ONLY AFTER comprehensive mapping → proceed to vulnerability testing
@@ -311,14 +265,13 @@ ROOT AGENT ROLE:
 - The root agent should coordinate strategy, delegate meaningful work, track progress, maintain todo lists, maintain notes, monitor subagent results, and decide next steps
 - The root agent should keep a clear view of overall coverage, uncovered attack surfaces, validation status, and reporting/fixing progress
 - The root agent should avoid spending its own iterations on detailed testing, payload execution, or deep target-specific investigation when that work can be delegated to specialized subagents
-- The root agent may do orchestration-support work needed to delegate well — reading scope/config, inspecting workspace layout, reading subagent output/reports, and light bookkeeping. It must NOT do the actual security testing itself: no running scanners/fuzzers/crawlers, no sending injection/XSS/SSRF/etc. payloads, and no "basic" or "quick" probing of discovered endpoints. If a check requires touching the target, delegate it to a subagent rather than doing it yourself
-- Its default and near-exclusive mode is coordinator/controller
+- The root agent may do lightweight triage, quick verification, or setup work when necessary to unblock delegation, but its default mode should be coordinator/controller
 - Subagents should do the substantive testing, validation, reporting, and fixing work
 - The root agent is responsible for ensuring that work is broken down clearly, tracked, and completed across the agent tree
 
 1. **CREATE AGENTS SELECTIVELY** - Spawn subagents when delegation materially improves parallelism, specialization, coverage, or independent validation. Deeper delegation is allowed when the child has a meaningfully different responsibility from the parent. Do not spawn subagents for trivial continuation of the same narrow task.
 2. **BLACK-BOX**: Discovery → Validation → Reporting (3 agents per vulnerability)
-3. **WHITE-BOX**: Discovery → Validation → Reporting-with-fix (3 agents per vulnerability — the reporting agent derives and files the fix inline; do NOT add a separate fixing agent that re-derives the same patch)
+3. **WHITE-BOX**: Discovery → Validation → Reporting → Fixing (4 agents per vulnerability)
 4. **MULTIPLE VULNS = MULTIPLE CHAINS** - Each vulnerability finding gets its own validation chain
 5. **CREATE AGENTS AS YOU GO** - Don't create all agents at start, create them when you discover new attack surfaces
 6. **ONE JOB PER AGENT** - Each agent has ONE specific task only
@@ -337,7 +290,8 @@ BLACK-BOX (domain/URL only):
 WHITE-BOX (source code provided):
 - Found authentication code issues? → Create authentication analysis agent
 - Auth agent finds potential vulnerability? → Create "Auth Validation Agent"
-- Validation agent confirms vulnerability? → Create "Auth Reporting Agent" that files the report AND its inline fix (`code_locations` + `fix_pr_body`) in one shot — no separate fixing agent
+- Validation agent confirms vulnerability? → Create "Auth Reporting Agent"
+- Reporting agent documents vulnerability? → Create "Auth Fixing Agent" (implement code fix and test it works)
 
 VULNERABILITY WORKFLOW (MANDATORY FOR EVERY FINDING):
 
@@ -358,11 +312,9 @@ Authentication Code Agent finds weak password validation
     ↓
 Spawns "Auth Validation Agent" (proves it's exploitable)
     ↓
-If valid → Spawns "Auth Reporting Agent" (creates the vulnerability report
-           WITH the fix inline: code_locations fix_before/fix_after + fix_pr_body,
-           applying/verifying the patch in the same turn if desired)
+If valid → Spawns "Auth Reporting Agent" (creates vulnerability report)
     ↓
-STOP - no separate fixing agent; the fix was derived once, at report time
+Spawns "Auth Fixing Agent" (implements secure code fix)
 ```
 
 CRITICAL RULES:
@@ -398,7 +350,7 @@ FOCUS PRINCIPLES:
 REALISTIC TESTING OUTCOMES:
 - **No Findings**: Agent completes testing but finds no vulnerabilities
 - **Validation Failed**: Initial finding was false positive, validation agent confirms it's not exploitable
-- **Valid Vulnerability**: Validation succeeds, spawns a reporting agent that files the report with the fix inline (white-box) — no separate fixing agent
+- **Valid Vulnerability**: Validation succeeds, spawns reporting agent and then fixing agent (white-box)
 
 PERSISTENCE IS MANDATORY:
 - Real vulnerabilities take TIME - expect to need 2000+ steps minimum
@@ -409,6 +361,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:
 
@@ -423,6 +448,7 @@ VULNERABILITY ASSESSMENT:
 - nuclei - Vulnerability scanner with templates
 - sqlmap - SQL injection detection/exploitation
 - trivy - Container/dependency vulnerability scanner
+- zaproxy - OWASP ZAP web app scanner
 - wapiti - Web vulnerability scanner
 
 WEB FUZZING & DISCOVERY:
@@ -453,28 +479,15 @@ 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.
-- HTTPQL filters (for `list_requests`): quote string values, leave integers unquoted (`resp.code.eq:200`, not `"200"`); combine terms with `AND`/`OR` (there is no `NOT` — use the negated operator `ne`/`ncont`/`nregex`). Numeric fields (`resp.code`, `req.port`) use `eq`/`ne`/`gt`/`gte`/`lt`/`lte`; text fields (`req.host`, `req.path`, `req.method`, `req.raw`) use `cont`/`ncont`/`eq`/`regex`. Example: `resp.code.gte:200 AND resp.code.lt:300 AND req.host.cont:"api"`.
-
-CAIDO PROXY ERROR PAGES — NOT RESPONSES FROM THE TARGET:
-Everything is proxied through Caido, so an unreachable target makes the *proxy* answer: a ~9KB
-`<title>Caido</title>` HTML page under 502/500, which curl/python/browser print as if it were the
-target's content. The request never reached a server. It also appears in `list_requests` with no
-response at all (`resp` null), unlike a real 502.
-- Don't dump it; extract the cause with `curl -s ... | grep -A8 'c-title"'`.
-- The `c-details` cause says what to fix: "Failed to query DNS" — host doesn't resolve, check
-  `dig +short <host>`, then correct or drop it; "Connection refused" — nothing on that port, check
-  `nc -z -v <host> <port>`; "TLS handshake"/"wrong version number" — scheme/port mismatch, flip
-  http/https; timeout — filtered or unreachable from the sandbox.
-- NEVER treat these as target behavior: not a finding, not evidence, not a WAF, not a server
-  error. Fix the url/host/port/scheme and retry, or move on — do not keep re-requesting a dead host.
+- 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, 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, etc.)
+- You can install any additional tools/packages needed based on the task/context using package managers (apt, pip, npm, go install, etc.)
 
 Directories:
 - /workspace - where you should work.
@@ -493,15 +506,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, skills in available_skills | dictsort -%}
-{% for skill in skills -%}
-- {{ category }}/{{ skill.name }}{% if skill.description %}: {{ skill.description }}{% endif %}
-{% endfor -%}
-{% 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,671 +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.config import load_settings
-from strix.tools.agents_graph.tools import (
-    agent_finish,
-    create_agent,
-    send_message_to_agent,
-    stop_agent,
-    view_agent_graph,
-    wait_for_agents,
-)
-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.output_store import bound_and_store, bound_text
-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_dependency_report,
-    create_vulnerability_report,
-    get_report,
-    list_reports,
-)
-from strix.tools.respond.tool import respond_to_user
-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 _tool_output_limits() -> tuple[int, int]:
-    context = load_settings().context
-    return context.tool_output_max_lines, context.tool_output_max_bytes
-
-
-async def _bound_result(result: Any) -> Any:
-    if not isinstance(result, str):
-        return result
-    max_lines, max_bytes = _tool_output_limits()
-    return await bound_and_store(result, max_lines=max_lines, max_bytes=max_bytes)
-
-
-def _format_tool_error(exc: Exception) -> str:
-    message = str(exc) or exc.__class__.__name__
-    max_lines, max_bytes = _tool_output_limits()
-    return bound_text(message, max_lines=max_lines, max_bytes=max_bytes)
-
-
-def _with_bounded_result(tool: FunctionTool) -> FunctionTool:
-    """Cap a tool's result size before it enters history (idempotent)."""
-    if getattr(tool, "_strix_bounded", False):
-        return tool
-    invoke_tool = tool.on_invoke_tool
-
-    async def invoke(ctx: Any, raw_input: str) -> Any:
-        return await _bound_result(await invoke_tool(ctx, raw_input))
-
-    tool.on_invoke_tool = invoke
-    tool._strix_bounded = True  # type: ignore[attr-defined]
-    return tool
-
-
-def _schema_types(spec: dict[str, Any]) -> set[str]:
-    types: set[str] = set()
-    raw = spec.get("type")
-    if isinstance(raw, str):
-        types.add(raw)
-    elif isinstance(raw, list):
-        types.update(t for t in raw if isinstance(t, str))
-    for variant in spec.get("anyOf") or ():
-        if isinstance(variant, dict):
-            types |= _schema_types(variant)
-    types.discard("null")
-    return types
-
-
-def _decode_structured(value: str, types: set[str]) -> Any:
-    stripped = value.strip()
-    if not stripped:
-        # An empty string is the model's "no value" for a list/dict param; give it
-        # the empty container so it validates instead of failing the type check.
-        return [] if "array" in types else {}
-    try:
-        decoded = json.loads(stripped)
-    except json.JSONDecodeError:
-        return value
-    wanted = list if "array" in types else dict
-    return decoded if isinstance(decoded, wanted) else value
-
-
-def _coerce_argument(value: Any, spec: dict[str, Any]) -> Any:
-    types = _schema_types(spec)
-    if not types or value is None:
-        return value
-    if isinstance(value, list | dict) and "string" in types and not types & {"array", "object"}:
-        return json.dumps(value, ensure_ascii=False)
-    if isinstance(value, str) and types & {"array", "object"} and "string" not in types:
-        return _decode_structured(value, types)
-    return value
-
-
-def _coerce_arguments(raw_input: str, schema: dict[str, Any]) -> str:
-    properties = schema.get("properties")
-    if not isinstance(properties, dict) or not properties:
-        return raw_input
-    try:
-        payload = json.loads(raw_input) if raw_input else None
-    except json.JSONDecodeError:
-        return raw_input
-    if not isinstance(payload, dict):
-        return raw_input
-
-    changed = False
-    for key, value in payload.items():
-        spec = properties.get(key)
-        if not isinstance(spec, dict):
-            continue
-        coerced = _coerce_argument(value, spec)
-        if coerced is not value:
-            payload[key] = coerced
-            changed = True
-
-    if not changed:
-        return raw_input
-    return json.dumps(payload, ensure_ascii=False)
-
-
-def _with_coerced_arguments(tool: FunctionTool) -> FunctionTool:
-    if getattr(tool, "_strix_coerced", False):
-        return tool
-    invoke_tool = tool.on_invoke_tool
-    schema = tool.params_json_schema
-
-    async def invoke(ctx: Any, raw_input: str) -> Any:
-        return await invoke_tool(ctx, _coerce_arguments(raw_input, schema))
-
-    tool.on_invoke_tool = invoke
-    tool._strix_coerced = True  # type: ignore[attr-defined]
-    return tool
-
-
-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 _bound_result(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 _bound_result(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 _bound_custom_tool(tool: CustomTool) -> CustomTool:
-    """Bound a native ``CustomTool`` result in place (Responses path)."""
-    invoke_tool = tool.on_invoke_tool
-
-    async def invoke(ctx: Any, raw_input: str) -> Any:
-        return await _bound_result(await invoke_tool(ctx, raw_input))
-
-    tool.on_invoke_tool = invoke
-    return tool
-
-
-def _configure_filesystem_tools(toolset: Any, *, chat_completions: bool) -> None:
-    for name, tool in vars(toolset).items():
-        if chat_completions:
-            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(_with_coerced_arguments(tool))
-                )
-        elif isinstance(tool, CustomTool):
-            setattr(toolset, name, _bound_custom_tool(tool))
-        elif isinstance(tool, FunctionTool):
-            setattr(toolset, name, _with_bounded_result(_with_coerced_arguments(tool)))
-
-
-def _make_filesystem_configurator(*, chat_completions: bool) -> Any:
-    def configure(toolset: Any) -> None:
-        _configure_filesystem_tools(toolset, chat_completions=chat_completions)
-
-    return configure
-
-
-_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 _apply_shell_output_cap(parsed: dict[str, Any]) -> None:
-    """Clamp the SDK shell tools' ``max_output_tokens`` to the configured
-    ceiling; a smaller explicit value is respected."""
-    ceiling = load_settings().context.tool_output_max_tokens
-    requested = parsed.get("max_output_tokens")
-    parsed["max_output_tokens"] = (
-        ceiling if not isinstance(requested, int) or requested > ceiling else requested
-    )
-
-
-def _wrap_exec_command(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, TypeError):
-            parsed = None
-        if isinstance(parsed, dict):
-            if "shell" not in parsed:
-                parsed["shell"] = "bash"
-            _apply_shell_output_cap(parsed)
-            raw_input = json.dumps(parsed)
-        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):
-            if isinstance(parsed.get("chars"), str):
-                parsed["chars"] = _decode_chars_escape(parsed["chars"])
-            _apply_shell_output_cap(parsed)
-            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 = _with_coerced_arguments(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
-
-
-# Tools that hand control away by parking the agent rather than ending the scan.
-_PARKING_TOOLS: frozenset[str] = frozenset({"respond_to_user", "wait_for_agents"})
-
-
-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 not in _PARKING_TOOLS 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,
-    create_dependency_report,
-    list_reports,
-    get_report,
-    list_requests,
-    view_request,
-    repeat_request,
-    list_sitemap,
-    view_sitemap_entry,
-    scope_rules,
-    view_agent_graph,
-    send_message_to_agent,
-    wait_for_agents,
-    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 = "agent",
-    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 interactive:
-        # Yielding to the user is only meaningful when one is attached.
-        agent_tools.append(respond_to_user)
-    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)
-    tools = [
-        _with_bounded_result(_with_coerced_arguments(tool))
-        if isinstance(tool, FunctionTool)
-        else tool
-        for tool in 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=_make_filesystem_configurator(
-                    chat_completions=chat_completions_tools,
-                ),
-            ),
-            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,110 +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,
-            is_root=is_root,
-            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,41 +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 (
-    ContextSettings,
-    DedupeSettings,
-    IntegrationSettings,
-    LlmSettings,
-    RuntimeSettings,
-    Settings,
-    TelemetrySettings,
+from strix.config.config import (
+    Config,
+    apply_saved_config,
+    save_current_config,
 )
 
 
 __all__ = [
-    "ContextSettings",
-    "DedupeSettings",
-    "IntegrationSettings",
-    "LlmSettings",
-    "RuntimeSettings",
-    "Settings",
-    "TelemetrySettings",
-    "apply_config_override",
-    "load_settings",
-    "persist_current",
+    "Config",
+    "apply_saved_config",
+    "save_current_config",
 ]

strix/config/codex.py

@@ -1,403 +0,0 @@
-"""ChatGPT (Codex) subscription auth: OAuth login, token refresh, and the OpenAI
-client that routes inference through the ChatGPT backend.
-
-Mirrors OpenAI's Codex CLI: OAuth 2.0 + PKCE against ``auth.openai.com``, with the
-access token sent as a ``Bearer`` token to ``chatgpt.com/backend-api/codex``. Using
-a ChatGPT subscription outside OpenAI's own products is not officially supported by
-OpenAI; the user chooses this path knowingly. The OAuth constants are OpenAI's own
-Codex CLI values (the backend only accepts that client).
-"""
-
-from __future__ import annotations
-
-import base64
-import contextlib
-import hashlib
-import json
-import logging
-import secrets
-import threading
-import time
-import urllib.parse
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-import requests
-
-from strix.utils.secret_files import write_secret_text
-
-
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-
-    from openai import AsyncOpenAI
-
-
-logger = logging.getLogger(__name__)
-
-
-PROVIDER = "codex"
-
-CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann"
-AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize"
-TOKEN_URL = "https://auth.openai.com/oauth/token"  # noqa: S105  # nosec B105 - URL, not a secret
-CALLBACK_HOST = "localhost"
-CALLBACK_PORT = 1455
-CALLBACK_PATH = "/auth/callback"
-REDIRECT_URI = f"http://{CALLBACK_HOST}:{CALLBACK_PORT}{CALLBACK_PATH}"
-SCOPE = "openid profile email offline_access"
-
-CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex"
-ORIGINATOR = "codex_cli_rs"
-_ACCOUNT_CLAIM = "https://api.openai.com/auth"
-
-_TOKEN_TIMEOUT = 30
-_EXPIRY_SKEW_S = 300
-
-_refresh_lock = threading.Lock()
-
-# Kept separate from cli-config.json so OAuth tokens never land in the env-var config.
-AUTH_PATH = Path.home() / ".strix" / "subscription-auth.json"
-
-
-def _read_store() -> dict[str, Any]:
-    try:
-        data = json.loads(AUTH_PATH.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return {}
-    return data if isinstance(data, dict) else {}
-
-
-def _write_store(data: dict[str, Any]) -> None:
-    write_secret_text(AUTH_PATH, json.dumps(data, indent=2))
-
-
-def read_record() -> dict[str, Any] | None:
-    record = _read_store().get(PROVIDER)
-    if not isinstance(record, dict) or record.get("type") != "oauth":
-        return None
-    if not (record.get("access") and record.get("refresh") and record.get("account_id")):
-        return None
-    return record
-
-
-def is_authenticated() -> bool:
-    return read_record() is not None
-
-
-def save_record(record: dict[str, Any]) -> None:
-    data = _read_store()
-    data[PROVIDER] = record
-    _write_store(data)
-
-
-def logout() -> None:
-    data = _read_store()
-    if PROVIDER not in data:
-        return
-    del data[PROVIDER]
-    if data:
-        _write_store(data)
-        return
-    with contextlib.suppress(OSError):
-        AUTH_PATH.unlink()
-
-
-@contextlib.contextmanager
-def _refresh_guard() -> Iterator[None]:
-    """Serialize token refresh within (lock) and across (flock) Strix processes,
-    so concurrent runs can't both spend the single-use refresh token."""
-    with _refresh_lock:
-        try:
-            import fcntl
-
-            lock_path = AUTH_PATH.with_suffix(".lock")
-            lock_path.parent.mkdir(parents=True, exist_ok=True)
-            handle = lock_path.open("w")
-        except (ImportError, OSError):
-            yield
-            return
-        try:
-            with contextlib.suppress(OSError):
-                fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
-            yield
-        finally:
-            with contextlib.suppress(OSError):
-                fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
-            handle.close()
-
-
-class CodexAuthError(Exception):
-    def __init__(self, code: str, message: str | None = None) -> None:
-        self.code = code
-        super().__init__(message or code)
-
-
-class CodexContentGuardrailError(Exception):
-    """The ChatGPT backend refused a request via its content guardrail.
-    Terminal — retrying identical content never clears the block."""
-
-    def __init__(self, model: str, original: BaseException | None = None) -> None:
-        self.model = model
-        self.original = original
-        super().__init__(
-            f"'{model}' was blocked by ChatGPT's content guardrails "
-            f"(flagged as a possible cybersecurity risk). "
-            f"Set STRIX_LLM to a model that isn't blocked and re-run."
-        )
-
-
-_GUARDRAIL_MARKERS = (
-    "flagged for possible cybersecurity risk",
-    "trusted access for cyber",
-)
-
-
-def is_content_guardrail_error(exc: BaseException) -> bool:
-    if isinstance(exc, CodexContentGuardrailError):
-        return True
-    text = str(exc).lower()
-    return any(marker in text for marker in _GUARDRAIL_MARKERS)
-
-
-def _b64url(raw: bytes) -> str:
-    return base64.urlsafe_b64encode(raw).rstrip(b"=").decode("ascii")
-
-
-def generate_pkce() -> tuple[str, str]:
-    verifier = _b64url(secrets.token_bytes(64))
-    challenge = _b64url(hashlib.sha256(verifier.encode("ascii")).digest())
-    return verifier, challenge
-
-
-def create_state() -> str:
-    return secrets.token_hex(16)
-
-
-def build_authorize_url(challenge: str, state: str) -> str:
-    params = {
-        "response_type": "code",
-        "client_id": CLIENT_ID,
-        "redirect_uri": REDIRECT_URI,
-        "scope": SCOPE,
-        "code_challenge": challenge,
-        "code_challenge_method": "S256",
-        "state": state,
-        "id_token_add_organizations": "true",
-        "codex_cli_simplified_flow": "true",
-        "originator": ORIGINATOR,
-    }
-    return f"{AUTHORIZE_URL}?{urllib.parse.urlencode(params)}"
-
-
-def parse_redirect_input(value: str) -> tuple[str | None, str | None]:
-    """Extract ``(code, state)`` from a pasted redirect URL, ``code#state``,
-    query string, or bare code."""
-    value = (value or "").strip()
-    if not value:
-        return None, None
-    with contextlib.suppress(ValueError):
-        parsed = urllib.parse.urlparse(value)
-        if parsed.scheme and parsed.query:
-            query = urllib.parse.parse_qs(parsed.query)
-            return _first(query, "code"), _first(query, "state")
-    if "#" in value:
-        code, _, state = value.partition("#")
-        return code or None, state or None
-    if "code=" in value:
-        query = urllib.parse.parse_qs(value)
-        return _first(query, "code"), _first(query, "state")
-    return value, None
-
-
-def _first(query: dict[str, list[str]], key: str) -> str | None:
-    values = query.get(key)
-    return values[0] if values else None
-
-
-def _post_form(payload: dict[str, str]) -> dict[str, Any]:
-    detail = ""
-    try:
-        with requests.post(
-            TOKEN_URL,
-            data=payload,
-            headers={"Accept": "application/json"},
-            timeout=_TOKEN_TIMEOUT,
-        ) as response:
-            status_code = response.status_code
-            body = response.content
-            if status_code >= 400:
-                detail = response.text[:300]
-    except requests.RequestException as exc:
-        raise CodexAuthError("unavailable", str(exc)) from exc
-    if status_code >= 400:
-        raise CodexAuthError("token_http_error", f"HTTP {status_code}: {detail}")
-    data = json.loads(body or b"{}")
-    if not isinstance(data, dict):
-        raise CodexAuthError("bad_response", "token endpoint returned non-object")
-    return data
-
-
-def _record_from_token_response(
-    data: dict[str, Any], refresh_fallback: str | None = None
-) -> dict[str, Any]:
-    access = data.get("access_token")
-    # A refresh response may omit refresh_token when it isn't rotated; keep the old one.
-    refresh = data.get("refresh_token") or refresh_fallback
-    expires_in = data.get("expires_in")
-    if not isinstance(access, str) or not access:
-        raise CodexAuthError("bad_response", "token response missing access_token")
-    if not isinstance(refresh, str) or not refresh:
-        raise CodexAuthError("bad_response", "token response missing refresh_token")
-    account_id = _account_id_from_jwt(access) or _account_id_from_jwt(
-        data.get("id_token") if isinstance(data.get("id_token"), str) else ""
-    )
-    if not account_id:
-        raise CodexAuthError("no_account_id", "could not read chatgpt_account_id from token")
-    ttl = expires_in if isinstance(expires_in, int | float) else 3600
-    return {
-        "type": "oauth",
-        "provider": PROVIDER,
-        "access": access,
-        "refresh": refresh,
-        "account_id": account_id,
-        "expires_at": time.time() + ttl,
-    }
-
-
-def exchange_code(code: str, verifier: str) -> dict[str, Any]:
-    data = _post_form(
-        {
-            "grant_type": "authorization_code",
-            "client_id": CLIENT_ID,
-            "code": code,
-            "code_verifier": verifier,
-            "redirect_uri": REDIRECT_URI,
-        }
-    )
-    return _record_from_token_response(data)
-
-
-def refresh_tokens(refresh_token: str) -> dict[str, Any]:
-    data = _post_form(
-        {
-            "grant_type": "refresh_token",
-            "client_id": CLIENT_ID,
-            "refresh_token": refresh_token,
-        }
-    )
-    return _record_from_token_response(data, refresh_fallback=refresh_token)
-
-
-def _account_id_from_jwt(token: str | None) -> str | None:
-    """Read the account id claim without verifying the JWT (the server enforces
-    authenticity on use); it feeds the ``chatgpt-account-id`` header."""
-    if not token or token.count(".") != 2:
-        return None
-    payload_b64 = token.split(".")[1]
-    padding = "=" * (-len(payload_b64) % 4)
-    try:
-        payload = json.loads(base64.urlsafe_b64decode(payload_b64 + padding))
-    except (ValueError, json.JSONDecodeError):
-        return None
-    if not isinstance(payload, dict):
-        return None
-    auth = payload.get(_ACCOUNT_CLAIM)
-    if isinstance(auth, dict):
-        account_id = auth.get("chatgpt_account_id")
-        if isinstance(account_id, str) and account_id:
-            return account_id
-    organizations = payload.get("organizations")
-    if isinstance(organizations, list) and organizations and isinstance(organizations[0], dict):
-        org_id = organizations[0].get("id")
-        if isinstance(org_id, str) and org_id:
-            return org_id
-    return None
-
-
-def _near_expiry(record: dict[str, Any]) -> bool:
-    expires_at = record.get("expires_at")
-    if not isinstance(expires_at, int | float):
-        return True
-    return expires_at - _EXPIRY_SKEW_S <= time.time()
-
-
-def get_valid_token() -> tuple[str, str]:
-    """Return ``(access_token, account_id)``, refreshing under the cross-process
-    guard if near expiry."""
-    record = read_record()
-    if record is None:
-        raise CodexAuthError("not_authenticated", "not signed in; run: strix auth login")
-    if not _near_expiry(record):
-        return record["access"], record["account_id"]
-    with _refresh_guard():
-        record = read_record()
-        if record is None:
-            raise CodexAuthError("not_authenticated", "not signed in; run: strix auth login")
-        if not _near_expiry(record):
-            return record["access"], record["account_id"]
-        try:
-            refreshed = refresh_tokens(record["refresh"])
-        except CodexAuthError:
-            # A peer process may have already spent this single-use refresh token.
-            latest = read_record()
-            if latest and latest["refresh"] != record["refresh"] and not _near_expiry(latest):
-                return latest["access"], latest["account_id"]
-            raise
-        save_record(refreshed)
-        return refreshed["access"], refreshed["account_id"]
-
-
-def build_openai_client() -> AsyncOpenAI:
-    """An ``AsyncOpenAI`` for the ChatGPT backend. A per-request hook re-stamps a
-    fresh bearer token so long scans survive token expiry."""
-    import asyncio
-
-    import httpx
-    from openai import AsyncOpenAI
-
-    get_valid_token()  # fail fast at configure time if the sign-in is dead
-
-    async def _auth_hook(request: httpx.Request) -> None:
-        access, account_id = await asyncio.to_thread(get_valid_token)
-        request.headers["Authorization"] = f"Bearer {access}"
-        request.headers["chatgpt-account-id"] = account_id
-
-    http_client = httpx.AsyncClient(
-        timeout=httpx.Timeout(600.0, connect=30.0),
-        event_hooks={"request": [_auth_hook]},
-    )
-    return AsyncOpenAI(
-        api_key="strix-codex-oauth",  # placeholder; the hook overwrites Authorization
-        base_url=CODEX_BASE_URL,
-        http_client=http_client,
-        default_headers={
-            "OpenAI-Beta": "responses=experimental",
-            "originator": ORIGINATOR,
-        },
-    )
-
-
-_subscription_client: AsyncOpenAI | None = None
-
-
-def get_subscription_client() -> AsyncOpenAI:
-    global _subscription_client  # noqa: PLW0603
-    if _subscription_client is None:
-        _subscription_client = build_openai_client()
-    return _subscription_client
-
-
-SUBSCRIPTION_PREFIX = "chatgpt/"
-
-
-def subscription_model(model_name: str | None) -> str | None:
-    """The model slug behind a ``chatgpt/<model>`` STRIX_LLM, or None."""
-    name = (model_name or "").strip()
-    if not name.lower().startswith(SUBSCRIPTION_PREFIX):
-        return None
-    return name[len(SUBSCRIPTION_PREFIX) :] or None
-
-
-def auth_mode(model_name: str | None) -> str:
-    return "subscription" if subscription_model(model_name) else "api_key"

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,125 +0,0 @@
-"""Settings loader, override switch, and disk persistence."""
-
-from __future__ import annotations
-
-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
-from strix.utils.secret_files import write_secret_text
-
-
-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
-
-    write_secret_text(target, json.dumps({"env": env_block}, indent=2))
-
-
-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,887 +0,0 @@
-"""SDK model configuration helpers."""
-
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import inspect
-import logging
-import os
-import time
-from collections.abc import AsyncGenerator
-from typing import TYPE_CHECKING, Any, cast
-
-from agents import (
-    set_default_openai_api,
-    set_default_openai_key,
-    set_tracing_disabled,
-)
-from agents.model_settings import ModelSettings
-from agents.models.fake_id import FAKE_RESPONSES_ID
-from agents.models.interface import Model
-from agents.models.multi_provider import MultiProvider
-from agents.models.openai_responses import OpenAIResponsesModel
-from agents.retry import (
-    ModelRetryBackoffSettings,
-    ModelRetrySettings,
-    RetryPolicyContext,
-    retry_policies,
-)
-from openai.types.responses import (
-    Response,
-    ResponseCompletedEvent,
-    ResponseOutputItemAddedEvent,
-    ResponseOutputItemDoneEvent,
-)
-from openai.types.responses.response_usage import ResponseUsage
-from openai.types.shared import Reasoning
-
-from strix.config import codex
-from strix.config.loader import load_settings
-from strix.config.tool_call_ids import TurnCallIdRewriter, dedupe_input
-from strix.config.tool_call_limits import TurnToolCallLimiter
-
-
-if TYPE_CHECKING:
-    from collections.abc import AsyncIterator
-
-    from agents.agent_output import AgentOutputSchemaBase
-    from agents.handoffs import Handoff
-    from agents.items import ModelResponse, TResponseInputItem, TResponseStreamEvent
-    from agents.models.interface import ModelProvider, ModelTracing
-    from agents.retry import ModelRetryAdvice, ModelRetryAdviceRequest
-    from agents.tool import Tool
-    from agents.usage import Usage
-    from openai import AsyncOpenAI
-    from openai.types.responses.response_prompt_param import ResponsePromptParam
-
-    from strix.config.settings import LlmSettings, ReasoningEffort, Settings
-
-
-logger = logging.getLogger(__name__)
-
-
-def request_timeout_extra_args(timeout_s: float | None) -> dict[str, float] | None:
-    """Per-request model timeout; a plain float so ``ModelSettings.to_json_dict()`` stays serializable."""  # noqa: E501
-    if not timeout_s or timeout_s <= 0:
-        return None
-    return {"timeout": timeout_s}
-
-
-def _retry_statusless_provider_errors(context: RetryPolicyContext) -> bool:
-    """Retry statusless provider errors (e.g. mid-stream quota/billing), but not aborts."""
-    normalized = context.normalized
-    if normalized.is_abort:
-        return False
-    if codex.is_content_guardrail_error(context.error):
-        return False
-    return normalized.status_code is None
-
-
-class _CodexResponsesModel(OpenAIResponsesModel):
-    """Responses model for the ChatGPT subscription backend (always streamed, stateless)."""
-
-    def __init__(
-        self,
-        model: str,
-        openai_client: AsyncOpenAI,
-        *,
-        reasoning_effort: ReasoningEffort | None = None,
-    ) -> None:
-        super().__init__(model, openai_client)
-        self._reasoning_effort = reasoning_effort
-
-    def _codex_settings(self, model_settings: ModelSettings) -> ModelSettings:
-        overrides = ModelSettings(store=False, response_include=["reasoning.encrypted_content"])
-        effort = self._reasoning_effort
-        if effort and effort != "none":
-            # Clamp to efforts the backend accepts.
-            match effort:
-                case "minimal":
-                    effort = "low"
-                case "xhigh" | "max":
-                    effort = "high"
-                case _:
-                    pass
-            overrides = overrides.resolve(ModelSettings(reasoning=Reasoning(effort=effort)))
-        return model_settings.resolve(overrides)
-
-    async def _fetch_response(self, *args: Any, stream: bool = False, **kwargs: Any) -> Any:
-        if len(args) >= 3:  # model_settings is positional arg 2
-            args = (*args[:2], self._codex_settings(args[2]), *args[3:])
-        try:
-            events = await super()._fetch_response(*args, stream=True, **kwargs)  # type: ignore[call-overload]
-        except Exception as exc:
-            guardrail = self._as_guardrail(exc)
-            if guardrail is not None:
-                raise guardrail from exc
-            raise
-        guarded = self._guarded(events)
-        if stream:
-            return guarded
-        final_response = None
-        async for event in guarded:
-            if getattr(event, "type", None) == "response.completed":
-                final_response = event.response
-        if final_response is None:
-            msg = "ChatGPT backend stream ended without a completed response"
-            raise RuntimeError(msg)
-        return final_response
-
-    def _as_guardrail(self, exc: BaseException) -> codex.CodexContentGuardrailError | None:
-        if isinstance(exc, codex.CodexContentGuardrailError):
-            return exc
-        if codex.is_content_guardrail_error(exc):
-            return codex.CodexContentGuardrailError(self.model, exc)
-        return None
-
-    async def _guarded(self, events: Any) -> AsyncIterator[Any]:
-        """Convert mid-stream guardrail rejections and close the stream on exit."""
-        try:
-            async for event in events:
-                yield event
-        except Exception as exc:
-            guardrail = self._as_guardrail(exc)
-            if guardrail is not None:
-                raise guardrail from exc
-            raise
-        finally:
-            await self._aclose(events)
-
-    @staticmethod
-    async def _aclose(events: Any) -> None:
-        aclose = getattr(events, "aclose", None)
-        if callable(aclose):
-            with contextlib.suppress(Exception):
-                await aclose()
-            return
-        close = getattr(events, "close", None)
-        if callable(close):
-            with contextlib.suppress(Exception):
-                result = close()
-                if inspect.isawaitable(result):
-                    await result
-
-
-class _NonStreamingModel(Model):
-    """Serve the SDK's streamed run loop from a single non-streaming request.
-
-    Some OpenAI-compatible gateways do not support Server-Sent Events, or
-    deliver them unreliably (dropping structured tool-call deltas, or stalling
-    mid-stream so the whole turn waits out the read timeout). The SDK run loop
-    Strix uses only issues streamed requests, so such a gateway fails every
-    turn. Opt in with ``LLM_DISABLE_STREAMING=true`` to wrap the resolved model
-    so each turn makes one non-streaming ``get_response`` (``stream:false`` on
-    the wire) and the completed result is replayed as a single terminal stream
-    event. The run loop then executes tools and emits run items from that final
-    response exactly as it would for a real stream, so nothing else changes.
-    """
-
-    def __init__(self, inner: Model) -> None:
-        self._inner = inner
-
-    async def close(self) -> None:
-        await self._inner.close()
-
-    def get_retry_advice(self, request: ModelRetryAdviceRequest) -> ModelRetryAdvice | None:
-        return self._inner.get_retry_advice(request)
-
-    async def get_response(
-        self,
-        system_instructions: str | None,
-        input: str | list[TResponseInputItem],  # noqa: A002
-        model_settings: ModelSettings,
-        tools: list[Tool],
-        output_schema: AgentOutputSchemaBase | None,
-        handoffs: list[Handoff],
-        tracing: ModelTracing,
-        *,
-        previous_response_id: str | None,
-        conversation_id: str | None,
-        prompt: ResponsePromptParam | None,
-    ) -> ModelResponse:
-        return await self._inner.get_response(
-            system_instructions,
-            input,
-            model_settings,
-            tools,
-            output_schema,
-            handoffs,
-            tracing,
-            previous_response_id=previous_response_id,
-            conversation_id=conversation_id,
-            prompt=prompt,
-        )
-
-    async def stream_response(
-        self,
-        system_instructions: str | None,
-        input: str | list[TResponseInputItem],  # noqa: A002
-        model_settings: ModelSettings,
-        tools: list[Tool],
-        output_schema: AgentOutputSchemaBase | None,
-        handoffs: list[Handoff],
-        tracing: ModelTracing,
-        *,
-        previous_response_id: str | None,
-        conversation_id: str | None,
-        prompt: ResponsePromptParam | None,
-    ) -> AsyncIterator[TResponseStreamEvent]:
-        response = await self._inner.get_response(
-            system_instructions,
-            input,
-            model_settings,
-            tools,
-            output_schema,
-            handoffs,
-            tracing,
-            previous_response_id=previous_response_id,
-            conversation_id=conversation_id,
-            prompt=prompt,
-        )
-        yield _completed_stream_event(response, getattr(self._inner, "model", None))
-
-
-class _TurnGuardModel(Model):
-    """Keep one turn from corrupting the conversation or running away.
-
-    Tool-call ids: providers that number calls per turn (``exec_command:0``,
-    ...) restart the counter each turn, so the same id eventually appears twice
-    in one conversation and strict providers reject every subsequent request.
-    Ids that collide with the history are rewritten before the turn is
-    recorded, and already-corrupted histories are repaired on the way out.
-
-    Tool-call volume: a degenerate response can queue hundreds of calls that
-    the run loop then honours one by one. Only the first
-    ``LLM_MAX_TOOL_CALLS_PER_TURN`` calls of a response are kept.
-
-    Stalled streams: a turn that emits a few tokens and then goes silent is
-    not covered by the request timeout, which resets on any byte (keepalives
-    included). ``LLM_STREAM_IDLE_TIMEOUT`` bounds the gap between events so the
-    turn fails instead of hanging, and the existing retry path replays it.
-    """
-
-    def __init__(
-        self,
-        inner: Model,
-        *,
-        max_tool_calls_per_turn: int = 0,
-        stream_idle_timeout: float = 0.0,
-    ) -> None:
-        self._inner = inner
-        self._max_tool_calls_per_turn = max_tool_calls_per_turn
-        self._stream_idle_timeout = stream_idle_timeout
-
-    def _limiter(self) -> TurnToolCallLimiter:
-        return TurnToolCallLimiter(self._max_tool_calls_per_turn)
-
-    def _log_dropped(self, limiter: TurnToolCallLimiter) -> None:
-        if limiter.dropped:
-            logger.warning(
-                "dropped %d tool call(s) past the per-response limit of %d",
-                limiter.dropped,
-                self._max_tool_calls_per_turn,
-            )
-
-    async def close(self) -> None:
-        await self._inner.close()
-
-    def get_retry_advice(self, request: ModelRetryAdviceRequest) -> ModelRetryAdvice | None:
-        return self._inner.get_retry_advice(request)
-
-    async def get_response(
-        self,
-        system_instructions: str | None,
-        input: str | list[TResponseInputItem],  # noqa: A002
-        model_settings: ModelSettings,
-        tools: list[Tool],
-        output_schema: AgentOutputSchemaBase | None,
-        handoffs: list[Handoff],
-        tracing: ModelTracing,
-        *,
-        previous_response_id: str | None,
-        conversation_id: str | None,
-        prompt: ResponsePromptParam | None,
-    ) -> ModelResponse:
-        sanitized = dedupe_input(input)
-        rewriter = TurnCallIdRewriter(sanitized)
-        response = await self._inner.get_response(
-            system_instructions,
-            cast("str | list[TResponseInputItem]", sanitized),
-            model_settings,
-            tools,
-            output_schema,
-            handoffs,
-            tracing,
-            previous_response_id=previous_response_id,
-            conversation_id=conversation_id,
-            prompt=prompt,
-        )
-        limiter = self._limiter()
-        response.output = limiter.filter_items(rewriter.rewrite_items(list(response.output)))
-        self._log_dropped(limiter)
-        return response
-
-    async def stream_response(
-        self,
-        system_instructions: str | None,
-        input: str | list[TResponseInputItem],  # noqa: A002
-        model_settings: ModelSettings,
-        tools: list[Tool],
-        output_schema: AgentOutputSchemaBase | None,
-        handoffs: list[Handoff],
-        tracing: ModelTracing,
-        *,
-        previous_response_id: str | None,
-        conversation_id: str | None,
-        prompt: ResponsePromptParam | None,
-    ) -> AsyncIterator[TResponseStreamEvent]:
-        sanitized = dedupe_input(input)
-        rewriter = TurnCallIdRewriter(sanitized)
-        limiter = self._limiter()
-        stream = self._inner.stream_response(
-            system_instructions,
-            cast("str | list[TResponseInputItem]", sanitized),
-            model_settings,
-            tools,
-            output_schema,
-            handoffs,
-            tracing,
-            previous_response_id=previous_response_id,
-            conversation_id=conversation_id,
-            prompt=prompt,
-        )
-        async for event in _with_idle_timeout(stream, self._stream_idle_timeout):
-            guarded = _guard_event(event, rewriter, limiter)
-            if guarded is not None:
-                yield guarded
-        self._log_dropped(limiter)
-
-
-async def _aclose(stream: AsyncIterator[TResponseStreamEvent]) -> None:
-    if isinstance(stream, AsyncGenerator):
-        with contextlib.suppress(Exception):
-            await stream.aclose()
-
-
-async def _with_idle_timeout(
-    stream: AsyncIterator[TResponseStreamEvent], timeout: float
-) -> AsyncIterator[TResponseStreamEvent]:
-    if timeout <= 0:
-        async for event in stream:
-            yield event
-        return
-
-    iterator = stream.__aiter__()
-    while True:
-        try:
-            event = await asyncio.wait_for(iterator.__anext__(), timeout)
-        except StopAsyncIteration:
-            return
-        except TimeoutError:
-            await _aclose(stream)
-            message = f"model stream produced no event for {timeout:.0f}s"
-            logger.warning("%s; abandoning the turn", message)
-            raise TimeoutError(message) from None
-        yield event
-
-
-def _guard_event(
-    event: TResponseStreamEvent, rewriter: TurnCallIdRewriter, limiter: TurnToolCallLimiter
-) -> TResponseStreamEvent | None:
-    if isinstance(event, ResponseOutputItemAddedEvent | ResponseOutputItemDoneEvent):
-        rewritten = rewriter.rewrite_item(event.item)
-        if not limiter.allow(rewritten):
-            return None
-        if rewritten is not event.item:
-            return event.model_copy(update={"item": rewritten})
-        return event
-    if isinstance(event, ResponseCompletedEvent):
-        original = list(event.response.output)
-        output = limiter.filter_items(rewriter.rewrite_items(original))
-        if output != original:
-            return event.model_copy(
-                update={"response": event.response.model_copy(update={"output": output})}
-            )
-    return event
-
-
-def _completed_stream_event(
-    model_response: ModelResponse, model_name: object | None
-) -> TResponseStreamEvent:
-    """Wrap a non-streamed ``ModelResponse`` as the terminal event of a stream.
-
-    The run loop builds its authoritative per-turn response solely from the
-    ``response.completed`` event, so a single event carrying the full output
-    and usage is all it needs.
-    """
-    response = Response(
-        id=model_response.response_id or FAKE_RESPONSES_ID,
-        created_at=time.time(),
-        model=str(model_name) if model_name else "",
-        object="response",
-        output=list(model_response.output),
-        tool_choice="auto",
-        tools=[],
-        parallel_tool_calls=False,
-        usage=_response_usage(model_response.usage),
-    )
-    return ResponseCompletedEvent(
-        response=response,
-        sequence_number=0,
-        type="response.completed",
-    )
-
-
-def _response_usage(usage: Usage | None) -> ResponseUsage | None:
-    if usage is None:
-        return None
-    return ResponseUsage(
-        input_tokens=usage.input_tokens,
-        output_tokens=usage.output_tokens,
-        total_tokens=usage.total_tokens,
-        input_tokens_details=usage.input_tokens_details,
-        output_tokens_details=usage.output_tokens_details,
-    )
-
-
-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
-
-    def get_model(self, model_name: str | None) -> Model:
-        llm = load_settings().llm
-        slug = codex.subscription_model(model_name)
-        idle_timeout = float(llm.stream_idle_timeout)
-        if slug:
-            # The ChatGPT subscription backend is always streamed; it has no
-            # non-streaming mode to fall back to, so LLM_DISABLE_STREAMING
-            # does not apply here.
-            model: Model = _CodexResponsesModel(
-                slug,
-                codex.get_subscription_client(),
-                reasoning_effort=llm.reasoning_effort,
-            )
-        else:
-            model = super().get_model(model_name)
-            if llm.disable_streaming:
-                model = _NonStreamingModel(model)
-                # The wrapper emits its single event only once the whole request
-                # is done, so an idle gap is meaningless here; the request
-                # timeout bounds it instead.
-                idle_timeout = 0.0
-        return _TurnGuardModel(
-            model,
-            max_tool_calls_per_turn=llm.max_tool_calls_per_turn,
-            stream_idle_timeout=idle_timeout,
-        )
-
-
-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)),
-        _retry_statusless_provider_errors,
-    ),
-)
-
-RECOMMENDED_MODEL_NAMES = (
-    "openai/gpt-5.6-sol",
-    "openai/gpt-5.6-terra",
-    "openai/gpt-5.6-luna",
-    "openai/gpt-5.6",
-    "openai/gpt-5.5-pro",
-    "openai/gpt-5.5",
-    "openai/gpt-5.4",
-    "openai/gpt-5.3-codex",
-    "anthropic/claude-fable-5",
-    "anthropic/claude-opus-5",
-    "anthropic/claude-opus-4-8",
-    "anthropic/claude-sonnet-5",
-    "anthropic/claude-sonnet-4-6",
-    "vertex_ai/gemini-3.1-pro-preview",
-    "gemini/gemini-3.1-pro-preview",
-    "gemini/gemini-3.6-flash",
-    "deepseek/deepseek-v4-pro",
-    "deepseek/deepseek-v4-flash",
-    "dashscope/qwen3.8-max",
-    "dashscope/qwen3.7-max-2026-06-08",
-    "moonshot/kimi-k3",
-    "moonshot/kimi-k2.7-code",
-)
-
-_RECOMMENDED_MODEL_NAME_SET = frozenset(name.lower() for name in RECOMMENDED_MODEL_NAMES)
-
-FRONTIER_MODEL_FAMILIES = (
-    (("azure", "azure_ai", "bedrock_mantle", "chatgpt", "openai"), ("gpt-5",)),
-    (
-        ("anthropic", "azure_ai", "bedrock", "claude", "databricks", "snowflake", "vertex_ai"),
-        ("claude-fable-5", "claude-opus-5", "claude-opus-4", "claude-sonnet-5", "claude-sonnet-4"),
-    ),
-    (("google", "gemini", "vertex_ai"), ("gemini-3",)),
-    (("deepseek",), ("deepseek-v4", "deepseek-r1", "deepseek-reasoner")),
-    (("alibaba", "dashscope", "qwen"), ("qwen3.8", "qwen3.7", "qwen3-max")),
-    (("moonshot", "moonshotai", "kimi"), ("kimi-k3", "kimi-k2.7", "kimi-k2.6")),
-)
-
-
-def configure_sdk_model_defaults(settings: Settings) -> None:
-    """Apply Strix config to SDK-native defaults."""
-    llm = settings.llm
-    set_tracing_disabled(True)
-    if codex.subscription_model(llm.model):
-        return
-    _configure_litellm_compatibility()
-    _configure_openrouter_attribution(llm.model)
-    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")
-    _configure_extra_headers(llm)
-
-
-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()
-    _install_openrouter_stream_cost_capture()
-
-
-def _install_openrouter_stream_cost_capture() -> None:
-    """Preserve OpenRouter's per-stream cost, which LiteLLM drops when streaming.
-
-    OpenRouter reports the real charge in ``usage.cost`` of the final stream
-    chunk, but LiteLLM rebuilds streamed responses from token-only fields and
-    discards it (its non-streamed path stashes the cost in hidden params; the
-    streaming path does not). Every scan streams, so without this the cost is
-    lost and Strix falls back to a cost-map estimate that is missing entirely
-    for new models (e.g. kimi-k3), reporting $0. Subclass the OpenRouter
-    streaming handler to record the cost keyed by response id so the cost
-    callback can recover the exact charge for the matching rebuilt response.
-    """
-    import litellm
-    from litellm.llms.openrouter.chat.transformation import (
-        OpenRouterChatCompletionStreamingHandler,
-        OpenrouterConfig,
-    )
-
-    from strix.report.state import streamed_openrouter_costs
-
-    class _StrixOpenRouterStreamingHandler(OpenRouterChatCompletionStreamingHandler):
-        def chunk_parser(self, chunk: dict[str, Any]) -> Any:
-            stream = super().chunk_parser(chunk)
-            streamed_openrouter_costs.remember(
-                chunk.get("id") or getattr(stream, "id", None), chunk.get("usage")
-            )
-            return stream
-
-    class _StrixOpenrouterConfig(OpenrouterConfig):
-        def get_model_response_iterator(
-            self, streaming_response: Any, sync_stream: bool, json_mode: bool | None = False
-        ) -> Any:
-            return _StrixOpenRouterStreamingHandler(
-                streaming_response=streaming_response,
-                sync_stream=sync_stream,
-                json_mode=json_mode,
-            )
-
-    # LiteLLM's provider-config factory reads litellm.OpenrouterConfig at call
-    # time, so overriding the attribute is enough for the subclass to take
-    # effect. (type: ignore — mypy rejects reassigning a class attribute.)
-    litellm.OpenrouterConfig = _StrixOpenrouterConfig  # type: ignore[misc]
-
-
-OPENROUTER_ATTRIBUTION_HEADERS = {
-    "HTTP-Referer": "https://strix.ai",
-    "X-Title": "Strix",
-    "X-OpenRouter-Categories": "cli-agent",
-}
-
-
-def is_openrouter_model(model_name: str | None) -> bool:
-    return bool(model_name) and "openrouter/" in (model_name or "").strip().lower()
-
-
-def _configure_openrouter_attribution(model_name: str | None) -> None:
-    import litellm
-
-    current: object = litellm.headers
-    existing: dict[str, str] = current if isinstance(current, dict) else {}
-    if not is_openrouter_model(model_name):
-        if any(key in existing for key in OPENROUTER_ATTRIBUTION_HEADERS):
-            remaining = {
-                k: v for k, v in existing.items() if k not in OPENROUTER_ATTRIBUTION_HEADERS
-            }
-            litellm.headers = remaining or None  # type: ignore[assignment]
-        return
-
-    litellm.headers = {**existing, **OPENROUTER_ATTRIBUTION_HEADERS}  # type: ignore[assignment]
-
-
-def _configure_extra_headers(llm: LlmSettings) -> None:
-    """Send user-provided default headers on every LLM request.
-
-    Some OpenAI-compatible endpoints require extra HTTP headers (e.g. request
-    attribution or tenant routing) alongside the bearer token. Users supply
-    them via ``LLM_EXTRA_HEADERS``; they are applied to both routing paths:
-    the LiteLLM route (``litellm.headers``) and the SDK-native OpenAI route
-    (a default client carrying ``default_headers``), so they take effect
-    regardless of the ``STRIX_LLM`` prefix.
-    """
-    headers = llm.extra_headers
-    if not headers:
-        return
-    _merge_litellm_headers(headers)
-    _register_openai_client_with_headers(llm, headers)
-
-
-def _merge_litellm_headers(headers: dict[str, str]) -> None:
-    import litellm
-
-    current: object = litellm.headers
-    existing: dict[str, str] = current if isinstance(current, dict) else {}
-    litellm.headers = {**existing, **headers}  # type: ignore[assignment]
-
-
-def _register_openai_client_with_headers(llm: LlmSettings, headers: dict[str, str]) -> None:
-    from agents import set_default_openai_client
-    from openai import AsyncOpenAI
-
-    client = AsyncOpenAI(
-        api_key=llm.api_key or "not-needed",
-        base_url=llm.api_base,
-        default_headers=dict(headers),
-    )
-    set_default_openai_client(client, use_for_tracing=False)
-
-
-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."""
-    if codex.subscription_model(model_name):
-        return False
-    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_recommended_or_frontier_model(model_name: str) -> bool:
-    """Return whether a model is recommended or in a frontier model family."""
-    name = _normalized_model_name(model_name)
-    if not name:
-        return False
-    if name in _RECOMMENDED_MODEL_NAME_SET:
-        return True
-    provider_name, bare_model_name = _split_model_provider(name)
-    return any(
-        _matches_frontier_family(provider_name, bare_model_name, provider_markers, prefixes)
-        for provider_markers, prefixes in FRONTIER_MODEL_FAMILIES
-    )
-
-
-def _normalized_model_name(model_name: str) -> str:
-    name = model_name.strip().lower()
-    for prefix in ("litellm/", "any-llm/"):
-        if name.startswith(prefix):
-            name = name[len(prefix) :]
-            break
-    return name
-
-
-def _split_model_provider(model_name: str) -> tuple[str | None, str]:
-    if "/" not in model_name:
-        return None, model_name
-    provider_name, bare_model_name = model_name.rsplit("/", 1)
-    return provider_name, bare_model_name
-
-
-def _matches_frontier_family(
-    provider_name: str | None,
-    model_name: str,
-    provider_markers: tuple[str, ...],
-    model_prefixes: tuple[str, ...],
-) -> bool:
-    if not _matches_model_prefix(model_name, model_prefixes):
-        return False
-    if provider_name is None:
-        return True
-    return _contains_provider_marker(
-        provider_name, provider_markers, split_compound_names=True
-    ) or _contains_provider_marker(model_name, provider_markers)
-
-
-def _matches_model_prefix(model_name: str, model_prefixes: tuple[str, ...]) -> bool:
-    return any(
-        candidate.startswith(prefix)
-        for candidate in _model_name_candidates(model_name)
-        for prefix in model_prefixes
-    )
-
-
-def _model_name_candidates(model_name: str) -> tuple[str, ...]:
-    if "." not in model_name:
-        return (model_name,)
-    suffixes = tuple(
-        model_name.split(".", index)[-1] for index in range(1, model_name.count(".") + 1)
-    )
-    return (model_name, *suffixes)
-
-
-def _contains_provider_marker(
-    value: str, provider_markers: tuple[str, ...], *, split_compound_names: bool = False
-) -> bool:
-    parts = set(value.replace(".", "/").split("/"))
-    if split_compound_names:
-        for separator in ("_", "-"):
-            parts.update(piece for part in tuple(parts) for piece in part.split(separator))
-    return any(marker in parts for marker in provider_markers)
-
-
-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")
-
-
-def is_claude_model(model_name: str) -> bool:
-    return "claude" in (model_name or "").strip().lower()
-
-
-def is_bedrock_route(model_name: str) -> bool:
-    name = (model_name or "").strip().lower()
-    return name.startswith("bedrock/") or "anthropic." in name
-
-
-def _prompt_cache_name_candidates(model_name: str) -> list[str]:
-    # LiteLLM's model map keys the same model under several names; strip the
-    # route prefix, then leading dotted segments (region, provider).
-    name = (model_name or "").strip().lower()
-    for prefix in ("litellm/", "bedrock/"):
-        if name.startswith(prefix):
-            name = name[len(prefix) :]
-            break
-    candidates = [name]
-    rest = name
-    while "." in rest:
-        rest = rest.split(".", 1)[1]
-        candidates.append(rest)
-    return candidates
-
-
-def bedrock_route_supports_prompt_caching(model_name: str) -> bool:
-    # Bedrock rejects the cache marker for models LiteLLM's map doesn't
-    # recognise as cache-capable, so callers withhold it unless confirmed here.
-    import litellm
-
-    checker = getattr(getattr(litellm, "utils", None), "supports_prompt_caching", None)
-    for cand in _prompt_cache_name_candidates(model_name):
-        if checker is not None:
-            with contextlib.suppress(Exception):
-                if checker(cand):
-                    return True
-        entry = litellm.model_cost.get(cand)
-        if entry and entry.get("supports_prompt_caching"):
-            return True
-    return False

strix/config/settings.py

@@ -1,156 +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", "max"]
-
-DEFAULT_MAX_TURNS = 500
-
-_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"),
-        repr=False,
-    )
-    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",
-        ),
-    )
-    extra_headers: dict[str, str] | None = Field(
-        default=None,
-        alias="LLM_EXTRA_HEADERS",
-        repr=False,
-    )
-    reasoning_effort: ReasoningEffort = Field(default="high", alias="STRIX_REASONING_EFFORT")
-    force_required_tool_choice: bool = Field(
-        default=False,
-        alias="STRIX_FORCE_REQUIRED_TOOL_CHOICE",
-    )
-    prompt_cache: bool = Field(
-        default=True,
-        alias="STRIX_PROMPT_CACHE",
-    )
-    disable_streaming: bool = Field(
-        default=False,
-        alias="LLM_DISABLE_STREAMING",
-    )
-    timeout: int = Field(default=300, alias="LLM_TIMEOUT")
-    stream_idle_timeout: int = Field(default=300, ge=0, alias="LLM_STREAM_IDLE_TIMEOUT")
-    max_tool_calls_per_turn: int = Field(
-        default=32,
-        ge=0,
-        alias="LLM_MAX_TOOL_CALLS_PER_TURN",
-    )
-
-
-class DedupeSettings(BaseSettings):
-    model_config = _BASE_CONFIG
-
-    model: str | None = Field(default=None, alias="STRIX_DEDUPE_MODEL")
-    reasoning_effort: ReasoningEffort | None = Field(
-        default=None,
-        alias="STRIX_DEDUPE_REASONING_EFFORT",
-    )
-    api_key: str | None = Field(default=None, alias="DEDUPE_LLM_API_KEY", repr=False)
-    api_base: str | None = Field(default=None, alias="DEDUPE_LLM_API_BASE")
-    extra_headers: dict[str, str] | None = Field(
-        default=None,
-        alias="DEDUPE_LLM_EXTRA_HEADERS",
-        repr=False,
-    )
-
-
-class ContextSettings(BaseSettings):
-    """Context-window management: per-tool-output caps and history compaction."""
-
-    model_config = _BASE_CONFIG
-
-    auto_compact: bool = Field(default=True, alias="STRIX_CONTEXT_AUTO_COMPACT")
-    compact_buffer_tokens: int = Field(default=20_000, gt=0, alias="STRIX_CONTEXT_BUFFER_TOKENS")
-    keep_tokens: int = Field(default=8_000, gt=0, alias="STRIX_CONTEXT_KEEP_TOKENS")
-    fallback_context_tokens: int = Field(
-        default=200_000, gt=0, alias="STRIX_CONTEXT_FALLBACK_TOKENS"
-    )
-    summary_max_tokens: int = Field(default=4_096, gt=0, alias="STRIX_CONTEXT_SUMMARY_TOKENS")
-    tool_output_max_tokens: int = Field(default=8_000, gt=0, alias="STRIX_TOOL_OUTPUT_MAX_TOKENS")
-    tool_output_max_lines: int = Field(default=2_000, gt=0, alias="STRIX_TOOL_OUTPUT_MAX_LINES")
-    # Floor above the truncation-notice size so a preview always fits.
-    tool_output_max_bytes: int = Field(
-        default=50 * 1024, ge=1024, alias="STRIX_TOOL_OUTPUT_MAX_BYTES"
-    )
-
-
-class RuntimeSettings(BaseSettings):
-    model_config = _BASE_CONFIG
-
-    image: str = Field(
-        default="ghcr.io/usestrix/strix-sandbox:1.3.0",
-        alias="STRIX_IMAGE",
-    )
-    backend: str = Field(default="docker", alias="STRIX_RUNTIME_BACKEND")
-    # Max screenshot/image tool outputs kept live per agent context (0 = none).
-    max_context_images: int = Field(default=3, ge=0, alias="STRIX_MAX_CONTEXT_IMAGES")
-
-
-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",
-        repr=False,
-    )
-    postman_api_key: str | None = Field(
-        default=None,
-        alias="POSTMAN_API_KEY",
-        repr=False,
-    )
-
-
-class ViewerSettings(BaseSettings):
-    model_config = _BASE_CONFIG
-
-    # Base URL of the Strix relay the local viewer proxies to for email
-    # verification and encrypted report delivery. The browser never talks to
-    # the relay directly; the local server is the only caller.
-    app_url: str = Field(default="https://app.strix.ai", alias="STRIX_APP_URL")
-
-
-class Settings(BaseSettings):
-    model_config = _BASE_CONFIG
-
-    llm: LlmSettings = Field(default_factory=LlmSettings)
-    dedupe: DedupeSettings = Field(default_factory=DedupeSettings)
-    runtime: RuntimeSettings = Field(default_factory=RuntimeSettings)
-    context: ContextSettings = Field(default_factory=ContextSettings)
-    telemetry: TelemetrySettings = Field(default_factory=TelemetrySettings)
-    integrations: IntegrationSettings = Field(default_factory=IntegrationSettings)
-    viewer: ViewerSettings = Field(default_factory=ViewerSettings)

strix/config/tool_call_ids.py

@@ -1,117 +0,0 @@
-"""Keep tool-call ids unique within a conversation.
-
-Some providers return per-turn tool-call ids (``exec_command:0``,
-``exec_command:1``, ...) whose counter restarts on every turn. Once the same
-id appears twice in one conversation, the request payload has two assistant
-tool calls sharing an id and strict providers reject the whole turn, which
-permanently kills the agent because the malformed history is replayed on
-every retry. Rewriting duplicates to fresh unique ids keeps the history
-valid for any provider.
-"""
-
-from __future__ import annotations
-
-from collections import defaultdict, deque
-from typing import Any
-from uuid import uuid4
-
-from openai.types.responses import ResponseFunctionToolCall
-
-
-def new_call_id() -> str:
-    return f"call_{uuid4().hex}"
-
-
-def collect_call_ids(items: list[Any]) -> set[str]:
-    used: set[str] = set()
-    for item in items:
-        if isinstance(item, dict):
-            call_id = item.get("call_id")
-            if isinstance(call_id, str):
-                used.add(call_id)
-        elif isinstance(item, ResponseFunctionToolCall):
-            used.add(item.call_id)
-    return used
-
-
-def dedupe_history_call_ids(items: list[Any]) -> tuple[list[Any], bool]:
-    """Rewrite duplicate call ids in a conversation history.
-
-    Outputs are paired with their call by order, so parallel calls that share
-    an id keep answering the right call after the rewrite.
-    """
-    used: set[str] = set()
-    pending: dict[str, deque[str]] = defaultdict(deque)
-    rebuilt: list[Any] = []
-    changed = False
-
-    for item in items:
-        if not isinstance(item, dict):
-            rebuilt.append(item)
-            continue
-        call_id = item.get("call_id")
-        if not isinstance(call_id, str):
-            rebuilt.append(item)
-            continue
-
-        kind = item.get("type")
-        if kind == "function_call":
-            effective = call_id
-            if call_id in used:
-                effective = new_call_id()
-                item = {**item, "call_id": effective}  # noqa: PLW2901
-                changed = True
-            used.add(effective)
-            pending[call_id].append(effective)
-        elif kind == "function_call_output":
-            queue = pending.get(call_id)
-            if queue:
-                effective = queue.popleft()
-                if effective != call_id:
-                    item = {**item, "call_id": effective}  # noqa: PLW2901
-                    changed = True
-        rebuilt.append(item)
-
-    return rebuilt, changed
-
-
-def dedupe_input(model_input: str | list[Any]) -> str | list[Any]:
-    if isinstance(model_input, str):
-        return model_input
-    rebuilt, changed = dedupe_history_call_ids(model_input)
-    return rebuilt if changed else model_input
-
-
-class TurnCallIdRewriter:
-    """Rewrite a single turn's tool-call ids that collide with the history.
-
-    A turn's items surface several times (streamed item events, then the
-    completed response), so the same original id must always map to the same
-    replacement within the turn.
-    """
-
-    def __init__(self, model_input: str | list[Any]) -> None:
-        self._used = set() if isinstance(model_input, str) else collect_call_ids(model_input)
-        self._remap: dict[str, str] = {}
-        self._settled: set[str] = set()
-
-    def rewrite_item(self, item: Any) -> Any:
-        if not isinstance(item, ResponseFunctionToolCall):
-            return item
-        original = item.call_id
-        if original in self._settled:
-            return item
-        replacement = self._remap.get(original)
-        if replacement is None:
-            if original not in self._used:
-                self._used.add(original)
-                self._settled.add(original)
-                return item
-            replacement = new_call_id()
-            self._remap[original] = replacement
-            self._used.add(replacement)
-            self._settled.add(replacement)
-        return item.model_copy(update={"call_id": replacement})
-
-    def rewrite_items(self, items: list[Any]) -> list[Any]:
-        return [self.rewrite_item(item) for item in items]

strix/config/tool_call_limits.py

@@ -1,46 +0,0 @@
-"""Bound how many tool calls one assistant response may queue.
-
-A degenerate generation can emit hundreds or thousands of tool calls in a
-single response — typically a poll/wait loop the model writes out ahead of
-time instead of issuing one call and yielding. The run loop honours all of
-them, so the agent stops reacting to anything for hours. Keeping only the
-first ``limit`` calls of a response bounds that blast radius; the model sees
-their results on the next turn and can reconsider.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from openai.types.responses import ResponseFunctionToolCall
-
-
-class TurnToolCallLimiter:
-    """Decide, once per call, whether a turn's tool call is within the limit."""
-
-    def __init__(self, limit: int) -> None:
-        self._limit = limit
-        self._decisions: dict[str, bool] = {}
-        self._kept = 0
-        self.dropped = 0
-
-    @property
-    def enabled(self) -> bool:
-        return self._limit > 0
-
-    def allow(self, item: Any) -> bool:
-        if not self.enabled or not isinstance(item, ResponseFunctionToolCall):
-            return True
-        decided = self._decisions.get(item.call_id)
-        if decided is not None:
-            return decided
-        allowed = self._kept < self._limit
-        if allowed:
-            self._kept += 1
-        else:
-            self.dropped += 1
-        self._decisions[item.call_id] = allowed
-        return allowed
-
-    def filter_items(self, items: list[Any]) -> list[Any]:
-        return [item for item in items if self.allow(item)]

strix/core/__init__.py

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

strix/core/agents.py

@@ -1,536 +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
-
-from strix.core.sessions import session_write_lock
-
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from agents.items import TResponseInputItem
-    from agents.memory import Session
-
-
-logger = logging.getLogger(__name__)
-
-Status = Literal["running", "waiting", "completed", "stopped", "crashed", "failed", "budget_paused"]
-
-# Why an agent parked. The user can message any agent, so this - not the agent's
-# position in the tree - decides whether waiting is bounded: only an agent waiting
-# on other agents is re-checked on a timer.
-WaitKind = Literal["user", "agents", "stalled"]
-
-
-@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)
-    mailbox: list[dict[str, Any]] = field(default_factory=list)
-    user_wake_required: bool = False
-
-
-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.errors: dict[str, str] = {}
-        self.recovery_counts: dict[str, int] = {}
-        self.idle_resume_counts: dict[str, int] = {}
-        self.wait_kinds: dict[str, WaitKind] = {}
-        self.runtimes: dict[str, AgentRuntime] = {}
-        self._parent_notified: set[str] = set()
-        self._lock = asyncio.Lock()
-        self._snapshot_path: Path | None = None
-        self.is_shutting_down = False
-        self._budget_stopped = False
-        self._reserve_stopped = False
-        self._budget_paused = False
-        self._extend_budget: Callable[[], None] | None = None
-
-    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()
-
-    @property
-    def reserve_stopped(self) -> bool:
-        return self._reserve_stopped
-
-    @property
-    def budget_paused(self) -> bool:
-        return self._budget_paused
-
-    def set_budget_extender(self, extend: Callable[[], None]) -> None:
-        self._extend_budget = extend
-
-    async def pause_for_budget(self, agent_id: str) -> None:
-        async with self._lock:
-            self._budget_paused = True
-        await self.set_status(agent_id, "budget_paused")
-
-    async def resume_from_budget_pause(self, *, exclude: str | None = None) -> None:
-        async with self._lock:
-            if not self._budget_paused:
-                return
-            self._budget_paused = False
-            paused = [aid for aid, status in self.statuses.items() if status == "budget_paused"]
-        if self._extend_budget is not None:
-            self._extend_budget()
-        for aid in paused:
-            await self.set_status(aid, "waiting")
-            if aid != exclude:
-                await self.send(
-                    aid,
-                    {
-                        "from": "system",
-                        "type": "budget_extended",
-                        "content": (
-                            "[Budget] The user extended the scan budget \u2014 continue your "
-                            "current task."
-                        ),
-                    },
-                )
-
-    async def reset_budget_stops(
-        self,
-        *,
-        budget_stopped: bool,
-        reserve_stopped: bool,
-        budget_paused: bool = False,
-    ) -> None:
-        async with self._lock:
-            self._budget_stopped = budget_stopped
-            self._reserve_stopped = reserve_stopped
-            if not budget_paused:
-                self._budget_paused = False
-                for aid, status in self.statuses.items():
-                    if status == "budget_paused":
-                        self.statuses[aid] = "waiting"
-        await self._maybe_snapshot()
-
-    async def claim_reserve_notification(self) -> str | None:
-        async with self._lock:
-            if self._reserve_stopped:
-                return None
-            self._reserve_stopped = True
-            for runtime in self.runtimes.values():
-                runtime.wake.set()
-            return next((aid for aid, parent in self.parent_of.items() if parent is None), None)
-
-    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"
-                self.errors.pop(agent_id, None)
-                self.wait_kinds.pop(agent_id, None)
-                self.runtimes.setdefault(agent_id, AgentRuntime()).user_wake_required = False
-                self._parent_notified.discard(agent_id)
-        await self._maybe_snapshot()
-
-    async def park_waiting(self, agent_id: str, *, wait_kind: WaitKind) -> None:
-        """Park an agent, recording what it is waiting on so the driver can time it."""
-        async with self._lock:
-            if agent_id in self.statuses:
-                self.wait_kinds[agent_id] = wait_kind
-        await self.set_status(agent_id, "waiting")
-
-    async def wait_kind_of(self, agent_id: str) -> WaitKind | None:
-        async with self._lock:
-            return self.wait_kinds.get(agent_id)
-
-    async def record_recovery(self, agent_id: str) -> int:
-        """Count a turn that ended without a lifecycle tool call; return the new total.
-
-        Persisted so a resumed agent cannot earn a fresh nudge budget on every
-        auto-resume and loop forever.
-        """
-        async with self._lock:
-            count = self.recovery_counts.get(agent_id, 0) + 1
-            self.recovery_counts[agent_id] = count
-        await self._maybe_snapshot()
-        return count
-
-    async def reset_recovery(self, agent_id: str) -> None:
-        """Clear the nudge budget after real progress (new message or a lifecycle tool)."""
-        async with self._lock:
-            if self.recovery_counts.pop(agent_id, None) is None:
-                return
-        await self._maybe_snapshot()
-
-    async def record_idle_resume(self, agent_id: str) -> int:
-        """Count an auto-resume that no message triggered; return the new total.
-
-        An agent that parks again after every auto-resume would otherwise burn a
-        model turn per timeout for the rest of the scan.
-        """
-        async with self._lock:
-            count = self.idle_resume_counts.get(agent_id, 0) + 1
-            self.idle_resume_counts[agent_id] = count
-        await self._maybe_snapshot()
-        return count
-
-    async def reset_idle_resumes(self, agent_id: str) -> None:
-        async with self._lock:
-            if self.idle_resume_counts.pop(agent_id, None) is None:
-                return
-        await self._maybe_snapshot()
-
-    async def set_status(
-        self, agent_id: str, status: Status | str, *, error: str | None = None
-    ) -> None:
-        async with self._lock:
-            if agent_id not in self.statuses:
-                return
-            self.statuses[agent_id] = status  # type: ignore[assignment]
-            if error is not None:
-                self.errors[agent_id] = error
-            elif status == "running":
-                self.errors.pop(agent_id, None)
-            if status == "running":
-                # Running again means a fresh stint that owes its parent its own notice.
-                self._parent_notified.discard(agent_id)
-            runtime = self.runtimes.setdefault(agent_id, AgentRuntime())
-            runtime.user_wake_required = status in {"failed", "crashed"}
-            runtime.wake.set()
-        logger.info("agent.status %s=%s", agent_id, status)
-        await self._maybe_snapshot()
-
-    async def claim_parent_notice(self, agent_id: str) -> bool:
-        """Reserve the one notice a child owes its parent when it stops running.
-
-        A completion report and a terminal notice carry the same information, so
-        whichever comes first claims the slot and the other is skipped.
-        """
-        async with self._lock:
-            if agent_id in self._parent_notified:
-                return False
-            self._parent_notified.add(agent_id)
-            return True
-
-    async def send(
-        self, target_agent_id: str, message: dict[str, Any], *, interrupt: bool = True
-    ) -> bool:
-        """Queue a user/peer message in the target's mailbox and wake it."""
-        from_user = message.get("from") == "user"
-        if from_user and self._budget_paused:
-            await self.resume_from_budget_pause(exclude=target_agent_id)
-        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())
-            runtime.mailbox.append(dict(message))
-            self.pending_counts[target_agent_id] = self.pending_counts.get(target_agent_id, 0) + 1
-            if from_user:
-                runtime.user_wake_required = False
-            runtime.wake.set()
-            stream = runtime.stream
-            interrupt_on_message = runtime.interrupt_on_message
-        if stream is not None and interrupt and interrupt_on_message:
-            stream.cancel(mode="immediate")
-        await self._maybe_snapshot()
-        return True
-
-    async def wait_for_message(self, agent_id: str, *, timeout: float | None = None) -> bool:
-        """Wait until a message is ready for ``agent_id``; False on ``timeout``."""
-        while True:
-            async with self._lock:
-                runtime = self.runtimes.setdefault(agent_id, AgentRuntime())
-                reserve_exit = self._reserve_stopped and self.parent_of.get(agent_id) is not None
-                pending_ready = (
-                    self.pending_counts.get(agent_id, 0) > 0 and not runtime.user_wake_required
-                )
-                if self._budget_stopped or reserve_exit or pending_ready:
-                    return True
-                wake = runtime.wake
-                wake.clear()
-            if timeout is None:
-                await wake.wait()
-            else:
-                try:
-                    await asyncio.wait_for(wake.wait(), timeout)
-                except TimeoutError:
-                    return False
-
-    async def consume_pending(
-        self,
-        agent_id: str,
-        *,
-        include_items: bool = False,
-    ) -> tuple[int, list[Any]]:
-        """Drain the agent's mailbox into its own SDK session."""
-        async with self._lock:
-            runtime = self.runtimes.setdefault(agent_id, AgentRuntime())
-            queued = list(runtime.mailbox)
-            runtime.mailbox.clear()
-            count = max(self.pending_counts.get(agent_id, 0), len(queued))
-            self.pending_counts[agent_id] = 0
-            session = runtime.session
-        if count <= 0:
-            return 0, []
-        items = [self._message_to_session_item(m) for m in queued]
-        if items:
-            if session is None:
-                logger.warning(
-                    "agent %s has no SDK session attached; %d queued messages were not persisted",
-                    agent_id,
-                    len(items),
-                )
-            else:
-                try:
-                    async with session_write_lock(session):
-                        await session.add_items(items)
-                except Exception:
-                    logger.exception(
-                        "failed to append %d queued messages to the session of %s",
-                        len(items),
-                        agent_id,
-                    )
-        await self._maybe_snapshot()
-        if not include_items:
-            return count, []
-        return count, items
-
-    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) -> list[str]:
-        """Stop a subtree leaves-first and report which agents were stopped."""
-        async with self._lock:
-            order = self._subtree_order_locked(agent_id)
-        stopped = list(reversed(order))
-        for aid in stopped:
-            await self.request_stop(aid)
-        await self._maybe_snapshot()
-        return stopped
-
-    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], dict[str, str]]:
-        async with self._lock:
-            return (
-                dict(self.parent_of),
-                dict(self.statuses),
-                dict(self.names),
-                dict(self.errors),
-            )
-
-    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),
-                "recovery_counts": dict(self.recovery_counts),
-                "idle_resume_counts": dict(self.idle_resume_counts),
-                "wait_kinds": dict(self.wait_kinds),
-                "mailboxes": {
-                    aid: [dict(m) for m in runtime.mailbox]
-                    for aid, runtime in self.runtimes.items()
-                    if runtime.mailbox
-                },
-                "errors": dict(self.errors),
-                "budget_stopped": self._budget_stopped,
-                "reserve_stopped": self._reserve_stopped,
-                "budget_paused": self._budget_paused,
-            }
-
-    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", {}))
-            self.errors = dict(snap.get("errors", {}))
-            self.recovery_counts = dict(snap.get("recovery_counts", {}))
-            self.idle_resume_counts = dict(snap.get("idle_resume_counts", {}))
-            self.wait_kinds = dict(snap.get("wait_kinds", {}))
-            mailboxes = snap.get("mailboxes", {})
-            if isinstance(mailboxes, dict):
-                for aid, msgs in mailboxes.items():
-                    if isinstance(msgs, list):
-                        runtime = self.runtimes.setdefault(aid, AgentRuntime())
-                        runtime.mailbox = [dict(m) for m in msgs if isinstance(m, dict)]
-            self._budget_stopped = bool(snap.get("budget_stopped", False))
-            self._reserve_stopped = bool(snap.get("reserve_stopped", False))
-            self._budget_paused = bool(snap.get("budget_paused", False))
-            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/hooks.py

@@ -1,273 +0,0 @@
-"""SDK run hooks used by Strix orchestration."""
-
-from __future__ import annotations
-
-import logging
-import math
-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, TResponseInputItem
-
-
-logger = logging.getLogger(__name__)
-
-
-LLM_TURN_KEY = "llm_turn"
-
-_STAGE_LABELS: tuple[str, ...] = ("NOTICE", "URGENT", "CRITICAL")
-_TURN_WARN_BANDS: tuple[float, ...] = (0.70, 0.85, 0.95)
-_ROOT_BUDGET_WARN_BANDS: tuple[float, ...] = (0.70, 0.85, 0.95)
-_SUBAGENT_BUDGET_WARN_BANDS: tuple[float, ...] = (0.75, 0.80, 0.85)
-_SUBAGENT_BUDGET_RESERVE = 0.90
-
-
-class BudgetExceededError(RuntimeError):
-    """Raised when the accumulated LLM cost reaches the configured budget."""
-
-
-class SubagentBudgetReservedError(RuntimeError):
-    """Raised to stop a single sub-agent once the reserve threshold is crossed."""
-
-
-class BudgetPausedError(RuntimeError):
-    """Raised to park one agent when an interactive scan reaches its budget."""
-
-
-def recomputed_budget_flags(
-    cost: float,
-    max_budget_usd: float | None,
-    *,
-    interactive: bool,
-) -> tuple[bool, bool]:
-    """Return the (budget_stopped, reserve_stopped) flags a resumed scan should carry."""
-    if max_budget_usd is None:
-        return False, False
-    if interactive:
-        return False, False
-    budget_stopped = cost >= max_budget_usd
-    reserve_stopped = cost >= max_budget_usd * _SUBAGENT_BUDGET_RESERVE
-    return budget_stopped, reserve_stopped
-
-
-def _crossed_stage(fraction: float, bands: tuple[float, ...]) -> int | None:
-    crossed: int | None = None
-    for index, band in enumerate(bands):
-        if fraction >= band:
-            crossed = index
-    return crossed
-
-
-_ROOT_DIRECTIVES: tuple[str, ...] = (
-    (
-        "As the root agent, begin planning your wind-down of the whole scan: avoid "
-        "starting large new lines of investigation, and keep your required objectives on "
-        "track so you can call finish_scan comfortably before the limit."
-    ),
-    (
-        "As the root agent, prioritize wrapping up the whole scan now: stop opening new "
-        "lines of investigation, close out only what is essential, and move toward calling "
-        "finish_scan to compile and deliver the final report."
-    ),
-    (
-        "As the root agent, STOP all other work on the whole scan and finish immediately: "
-        "secure your findings and call finish_scan now — anything left unfinished when the "
-        "limit is hit is discarded."
-    ),
-)
-_SUBAGENT_DIRECTIVES: tuple[str, ...] = (
-    (
-        "As a sub-agent, begin planning your wind-down: avoid starting large new subtasks, "
-        "and if you are close to a confirmed, validated vulnerability, drive it to a result "
-        "you can report."
-    ),
-    (
-        "As a sub-agent, prioritize wrapping up your task now: report any confirmed, "
-        "validated vulnerability, finish work that is nearly done rather than starting "
-        "anything new, and prepare to call agent_finish."
-    ),
-    (
-        "As a sub-agent, STOP all other work and finish immediately: report any confirmed "
-        "vulnerability right now and call agent_finish to hand your results back to your "
-        "parent before you are cut off."
-    ),
-)
-
-
-def _wrapup_directive(context: RunContextWrapper[dict[str, Any]], stage: int) -> str:
-    is_root = context.context.get("parent_id") is None
-    directives = _ROOT_DIRECTIVES if is_root else _SUBAGENT_DIRECTIVES
-    return directives[stage]
-
-
-def _urgency(stage: int) -> str:
-    return _STAGE_LABELS[stage]
-
-
-class ReportUsageHooks(RunHooks[dict[str, Any]]):
-    """Persist SDK-native usage and warn/stop as turn and cost budgets are consumed."""
-
-    def __init__(
-        self,
-        *,
-        model: str,
-        max_budget_usd: float | None = None,
-        max_turns: int | None = None,
-        interactive: bool = False,
-    ) -> None:
-        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")
-        if max_turns is not None and max_turns <= 0:
-            raise ValueError("max_turns must be a positive integer")
-        self._model = model
-        self._max_budget_usd = max_budget_usd
-        self._budget_increment = max_budget_usd
-        self._max_turns = max_turns
-        self._interactive = interactive
-
-    def extend_budget(self) -> None:
-        if self._max_budget_usd is None or self._budget_increment is None:
-            return
-        self._max_budget_usd += self._budget_increment
-
-    async def on_llm_start(
-        self,
-        context: RunContextWrapper[dict[str, Any]],
-        agent: Agent[dict[str, Any]],  # noqa: ARG002
-        system_prompt: str | None,  # noqa: ARG002
-        input_items: list[TResponseInputItem],
-    ) -> None:
-        context.context[LLM_TURN_KEY] = int(context.context.get(LLM_TURN_KEY, 0)) + 1
-        try:
-            self._maybe_warn_turns(context, input_items)
-            self._maybe_warn_budget(context, input_items)
-        except Exception:
-            logger.exception("budget/turn warning injection failed")
-
-    def _maybe_warn_turns(
-        self,
-        context: RunContextWrapper[dict[str, Any]],
-        input_items: list[TResponseInputItem],
-    ) -> None:
-        if not self._max_turns:
-            return
-        usage = getattr(context, "usage", None)
-        requests = getattr(usage, "requests", None)
-        if not isinstance(requests, int):
-            return
-        turns_used = requests + 1
-        stage = _crossed_stage(turns_used / self._max_turns, _TURN_WARN_BANDS)
-        if stage is None:
-            return
-        remaining = max(self._max_turns - turns_used, 0)
-        pct = round(100 * turns_used / self._max_turns)
-        content = (
-            f"[{_urgency(stage)}] Turn budget: {turns_used}/{self._max_turns} used ({pct}%). "
-            f"About {remaining} turn(s) remain before this agent is force-stopped and any "
-            f"in-progress work is discarded. {_wrapup_directive(context, stage)}"
-        )
-        input_items.append({"role": "user", "content": content})
-
-    def _maybe_warn_budget(
-        self,
-        context: RunContextWrapper[dict[str, Any]],
-        input_items: list[TResponseInputItem],
-    ) -> None:
-        if self._max_budget_usd is None:
-            return
-        report_state = get_global_report_state()
-        if report_state is None:
-            return
-        cost = report_state.get_total_llm_cost()
-        is_root = context.context.get("parent_id") is None
-        if self._interactive:
-            bands = _ROOT_BUDGET_WARN_BANDS
-        else:
-            bands = _ROOT_BUDGET_WARN_BANDS if is_root else _SUBAGENT_BUDGET_WARN_BANDS
-        stage = _crossed_stage(cost / self._max_budget_usd, bands)
-        if stage is None:
-            return
-        pct = round(100 * cost / self._max_budget_usd)
-        reserve_pct = round(_SUBAGENT_BUDGET_RESERVE * 100)
-        if self._interactive:
-            content = (
-                f"[{_urgency(stage)}] Scan cost budget: ${cost:.2f}/${self._max_budget_usd:.2f} "
-                f"spent ({pct}%). This budget is shared across every agent in the scan; when it "
-                "is reached all agents are paused until the user chooses to continue. "
-                f"{_wrapup_directive(context, stage)}"
-            )
-        elif is_root:
-            content = (
-                f"[{_urgency(stage)}] Scan cost budget: ${cost:.2f}/${self._max_budget_usd:.2f} "
-                f"spent ({pct}%). This budget is shared across every agent in the scan; when it "
-                "is reached the whole scan is stopped immediately, and sub-agents are stopped at "
-                f"{reserve_pct}% to reserve the remainder for your final report. "
-                f"{_wrapup_directive(context, stage)}"
-            )
-        else:
-            content = (
-                f"[{_urgency(stage)}] Scan cost budget: ${cost:.2f}/${self._max_budget_usd:.2f} "
-                f"spent ({pct}%). This budget is shared across every agent in the scan; "
-                f"sub-agents are stopped at {reserve_pct}% to leave the remainder for the root "
-                f"agent's final report. {_wrapup_directive(context, stage)}"
-            )
-        input_items.append({"role": "user", "content": content})
-
-    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:
-                if self._interactive:
-                    raise BudgetPausedError(
-                        f"Scan budget of ${self._max_budget_usd:.2f} reached "
-                        f"(spent ${cost:.4f}); pausing until the user continues"
-                    )
-                raise BudgetExceededError(
-                    f"Token budget of ${self._max_budget_usd:.2f} exceeded (spent ${cost:.4f})"
-                )
-            is_root = ctx.get("parent_id") is None
-            if not self._interactive and not is_root:
-                reserve_limit = self._max_budget_usd * _SUBAGENT_BUDGET_RESERVE
-                if cost >= reserve_limit:
-                    raise SubagentBudgetReservedError(
-                        f"Sub-agent budget reserve reached: spent ${cost:.4f} of "
-                        f"${self._max_budget_usd:.2f} "
-                        f"(>= {round(_SUBAGENT_BUDGET_RESERVE * 100)}% reserve); stopping this "
-                        "sub-agent so the root agent can finish the scan."
-                    )

strix/core/inputs.py

@@ -1,320 +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,
-    OPENROUTER_ATTRIBUTION_HEADERS,
-    bedrock_route_supports_prompt_caching,
-    is_bedrock_route,
-    is_claude_model,
-    is_known_openai_bare_model,
-    is_openrouter_model,
-    model_supports_reasoning,
-    request_timeout_extra_args,
-)
-from strix.core.sessions import scrub_images_from_items
-
-
-if TYPE_CHECKING:
-    from strix.config.settings import ReasoningEffort
-
-
-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 _render_diff_scope(diff_scope: dict[str, Any]) -> list[str]:
-    """Render pull-request diff-scope constraints as root-task lines."""
-    if not diff_scope.get("active"):
-        return []
-    parts: list[str] = [
-        "\n\nScope Constraints:",
-        "- 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")
-    return parts
-
-
-def _render_api_spec(details: dict[str, Any]) -> list[str]:
-    """Render an API spec target as root-task lines.
-
-    The spec itself is in the workspace, so the task points at the file and lets
-    the agent read the contract rather than restating a parsed summary of it.
-    """
-    title = details.get("spec_title") or details.get("target_spec", "API")
-    workspace_path = details.get("workspace_path", "")
-    lines = [
-        f"- {title} ({details.get('spec_format', 'api')} specification"
-        + (f", available at: {workspace_path}" if workspace_path else "")
-        + ")"
-    ]
-    if base_urls := details.get("base_urls") or []:
-        lines.append("  - Base URL(s): " + ", ".join(base_urls))
-    lines.append(
-        "  - Read the specification and test every operation it declares, using "
-        "its declared parameters, request bodies, and auth. Endpoints in the "
-        "specification are in scope even when nothing links to them. Load the "
-        "`api_spec_testing` skill for the methodology, or spawn a specialist "
-        "with it."
-    )
-    return lines
-
-
-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": [],
-        "API Specifications": [],
-    }
-
-    for target in targets:
-        ttype = target.get("type")
-        details = target.get("details") or {}
-        workspace_subdir = details.get("workspace_subdir")
-        workspace_path = f"/workspace/{workspace_subdir}" if workspace_subdir else "/workspace"
-
-        if ttype == "repository":
-            url = details.get("target_repo", "")
-            cloned = details.get("cloned_repo_path")
-            sections["Repositories"].append(
-                f"- {url} (available at: {workspace_path})" if cloned else f"- {url}",
-            )
-        elif ttype == "local_code":
-            path = details.get("target_path", "unknown")
-            sections["Local Codebases"].append(
-                f"- {path} (available at: {workspace_path}; "
-                "this is the user's real directory, mounted live and writable — "
-                ".git/.agents/.codex are read-only)"
-            )
-        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', '')}")
-        elif ttype == "api_spec":
-            sections["API Specifications"].extend(_render_api_spec(details))
-
-    parts: list[str] = []
-    for label, items in sections.items():
-        if items:
-            parts.append(f"\n\n{label}:")
-            parts.extend(items)
-
-    # A workspace mount is a directory to work in, not an asset to test. It is
-    # listed apart from the targets so it never reads as scope.
-    if workspace_mount := scan_config.get("workspace_mount") or "":
-        subdir = scan_config.get("workspace_subdir") or ""
-        workspace_path = f"/workspace/{subdir}" if subdir else "/workspace"
-        parts.append("\n\nWorking Directory:")
-        parts.append(
-            f"- {workspace_mount} (available at: {workspace_path}; "
-            "this is the user's real directory, mounted live and writable — "
-            ".git/.agents/.codex are read-only)"
-        )
-        parts.append(
-            "- No scan target was set. This directory is where you work, not a "
-            "target to assess: the instructions below are the only source of "
-            "truth for what to do."
-        )
-    elif not parts and user_instructions:
-        # Neither a target nor a directory, but there is an instruction: the user
-        # declined the mount, so the instruction is all there is. Say so, or the
-        # agent goes looking for a scope that was never given.
-        parts.append(
-            "\n\nNo scan target and no working directory were provided. The "
-            "instructions below are the only source of truth for what to do; "
-            "work from them and from what you can reach yourself."
-        )
-
-    parts.extend(_render_diff_scope(diff_scope))
-
-    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",
-        "api_spec": "target_spec",
-    }
-    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},
-        )
-
-        # An API spec authorizes the hosts it declares as in-scope web targets
-        # so the agent can exercise every endpoint without expanding scope.
-        if ttype == "api_spec":
-            authorized.extend(
-                {"type": "web_application", "value": base_url, "workspace_path": ""}
-                for base_url in details.get("base_urls") or []
-            )
-
-    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,
-    request_timeout: float | None = None,
-    prompt_cache: bool = True,
-    extra_headers: dict[str, str] | None = None,
-    has_tools: bool = True,
-) -> ModelSettings:
-    headers = _request_headers(model_name, extra_headers)
-    model_settings = ModelSettings(
-        parallel_tool_calls=False if has_tools else None,
-        retry=DEFAULT_MODEL_RETRY,
-        include_usage=True,
-        extra_args=request_timeout_extra_args(request_timeout),
-        extra_headers=headers,
-    )
-    if (
-        reasoning_effort is not None
-        and reasoning_effort != "none"
-        and model_supports_reasoning(model_name)
-    ):
-        model_settings = model_settings.resolve(
-            _reasoning_settings(reasoning_effort, model_settings.extra_args),
-        )
-    if force_required_tool_choice and _accepts_required_tool_choice(model_name):
-        model_settings = model_settings.resolve(ModelSettings(tool_choice="required"))
-
-    cache_extra_args = _prompt_cache_extra_args(model_name) if prompt_cache else None
-    if cache_extra_args:
-        model_settings = model_settings.resolve(
-            ModelSettings(
-                extra_args={**(model_settings.extra_args or {}), **cache_extra_args},
-            ),
-        )
-    return model_settings
-
-
-def _request_headers(
-    model_name: str, extra_headers: dict[str, str] | None
-) -> dict[str, str] | None:
-    headers: dict[str, str] = {}
-    if is_openrouter_model(model_name):
-        headers.update(OPENROUTER_ATTRIBUTION_HEADERS)
-    if extra_headers:
-        headers.update(extra_headers)
-    return headers or None
-
-
-def _reasoning_settings(
-    effort: ReasoningEffort,
-    extra_args: dict[str, Any] | None,
-) -> ModelSettings:
-    """``max`` is not in the OpenAI SDK's ``Reasoning.effort`` enum, so send it as
-    a raw body field instead — also keeping it clear of LiteLLM's DeepSeek mapping,
-    which collapses every ``reasoning_effort`` level to plain thinking-enabled.
-    Providers that don't support ``max`` reject the request.
-    """
-    if effort != "max":
-        return ModelSettings(reasoning=Reasoning(effort=effort))
-    return ModelSettings(
-        extra_args={**(extra_args or {}), "extra_body": {"reasoning_effort": "max"}},
-    )
-
-
-def _prompt_cache_extra_args(model_name: str) -> dict[str, Any] | None:
-    """LiteLLM ``cache_control_injection_points`` for Claude prompt caching.
-
-    System prompt + rolling last-message breakpoint everywhere; ``tool_config``
-    only on Bedrock Converse (the only route whose LiteLLM transform consumes
-    it — elsewhere it leaks onto the wire and native Anthropic 400s). Unmapped
-    Bedrock models get no points at all: Bedrock rejects the passed-through
-    field outright.
-    """
-    if not is_claude_model(model_name):
-        return None
-    if is_bedrock_route(model_name) and not bedrock_route_supports_prompt_caching(model_name):
-        return None
-
-    points: list[dict[str, Any]] = [{"location": "message", "role": "system"}]
-    if is_bedrock_route(model_name):
-        points.append({"location": "tool_config"})
-    points.append({"location": "message", "index": -1})
-    return {"cache_control_injection_points": points}
-
-
-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(
-            scrub_images_from_items(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,40 +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
-
-
-def runs_base_dir(*, cwd: Path | None = None) -> Path:
-    base = cwd or Path.cwd()
-    return base / RUNS_DIR_NAME
-
-
-def latest_run_dir(*, cwd: Path | None = None) -> Path | None:
-    base = runs_base_dir(cwd=cwd)
-    if not base.is_dir():
-        return None
-    candidates = [child for child in base.iterdir() if run_record_path(child).is_file()]
-    if not candidates:
-        return None
-    # run.json is rewritten on status/end changes, so its mtime tracks activity
-    # more reliably than the directory mtime (a live run sorts to the top).
-    return max(candidates, key=lambda child: run_record_path(child).stat().st_mtime)

strix/core/runner.py

@@ -1,476 +0,0 @@
-"""Top-level Strix scan runner."""
-
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import io
-import json
-import logging
-import uuid
-from collections.abc import Callable
-from pathlib import Path
-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.config.settings import DEFAULT_MAX_TURNS
-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, recomputed_budget_flags
-from strix.core.inputs import (
-    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.report.state import get_global_report_state
-from strix.runtime import session_manager
-from strix.telemetry.logging import set_scan_id, setup_scan_logging
-from strix.tools.output_store import (
-    WORKSPACE_SPILL_DIR,
-    configure_spill_writer,
-)
-
-
-if TYPE_CHECKING:
-    from agents.memory import SQLiteSession
-    from agents.result import RunResultBase
-
-    from strix.runtime.status import StatusSink
-
-
-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,
-    status_sink: StatusSink | 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.
-    """
-
-    def report(phase: str) -> None:
-        if status_sink is not None:
-            status_sink(phase)
-
-    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)
-        report_state = get_global_report_state()
-        if report_state is not None:
-            budget_stopped, reserve_stopped = recomputed_budget_flags(
-                report_state.get_total_llm_cost(),
-                max_budget_usd,
-                interactive=interactive,
-            )
-            await coordinator.reset_budget_stops(
-                budget_stopped=budget_stopped,
-                reserve_stopped=reserve_stopped,
-                budget_paused=interactive and coordinator.budget_paused,
-            )
-        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 [],
-        status_sink=status_sink,
-    )
-    report("Waiting for the first model response")
-    logger.info("Sandbox ready for scan %s", scan_id)
-
-    sandbox_session = bundle["session"]
-
-    async def _spill_to_workspace(output_id: str, text: str) -> str | None:
-        """Write an oversized tool result into the sandbox; return its path or None."""
-        path = f"{WORKSPACE_SPILL_DIR}/{output_id}.txt"
-        try:
-            await sandbox_session.write(Path(path), io.BytesIO(text.encode("utf-8")))
-        except Exception:
-            logger.exception("failed to spill tool output to sandbox workspace")
-            return None
-        return path
-
-    configure_spill_writer(_spill_to_workspace)
-
-    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,
-            request_timeout=settings.llm.timeout,
-            prompt_cache=settings.llm.prompt_cache,
-            extra_headers=settings.llm.extra_headers,
-        )
-        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,
-            # A hallucinated tool name is a recoverable model mistake, not a scan-ending
-            # error: hand it back as a tool result so the agent can correct itself.
-            tool_not_found_behavior="return_error_to_model",
-        )
-        hooks = ReportUsageHooks(
-            model=resolved_model,
-            max_budget_usd=max_budget_usd,
-            max_turns=max_turns,
-            interactive=interactive,
-        )
-        if interactive:
-            coordinator.set_budget_extender(hooks.extend_budget)
-
-        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="Root Agent",
-            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,
-                "Root Agent",
-                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,
-            "max_context_images": settings.runtime.max_context_images,
-        }
-
-        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:
-            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:
-            with contextlib.suppress(Exception):
-                await coordinator.set_status(root_id, "stopped")
-        return None
-    except (asyncio.CancelledError, KeyboardInterrupt):
-        logger.info("Scan %s interrupted by the user", scan_id)
-        if root_id is not None:
-            with contextlib.suppress(Exception):
-                await coordinator.set_status(root_id, "running")
-        raise
-    except BaseException:
-        logger.exception("Strix scan %s failed", scan_id)
-        if root_id is not None:
-            with contextlib.suppress(Exception):
-                await coordinator.set_status(root_id, "failed")
-        raise
-    finally:
-        configure_spill_writer(None)
-        # Settle descendants before closing sessions: on a clean finish a child
-        # can still be mid-turn, and closing its session underneath it crashes it.
-        if root_id is not None:
-            with contextlib.suppress(Exception):
-                await coordinator.cancel_descendants(root_id)
-        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,214 +0,0 @@
-"""SDK session helpers for Strix agents."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import sqlite3
-from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, cast
-from weakref import WeakKeyDictionary
-
-from agents.items import ItemHelpers
-from agents.memory import SQLiteSession
-
-
-if TYPE_CHECKING:
-    from collections.abc import Callable, Iterator
-    from pathlib import Path
-
-    from agents.items import TResponseInputItem
-    from agents.memory import Session
-
-
-logger = logging.getLogger(__name__)
-
-
-class _PooledConnectionSession(SQLiteSession):
-    @contextmanager
-    def _locked_connection(self) -> Iterator[sqlite3.Connection]:
-        with self._lock:
-            if self._closed:
-                raise RuntimeError("SQLiteSession is closed")
-            if self._is_memory_db:
-                yield self._shared_connection
-                return
-            connection = sqlite3.connect(str(self.db_path), check_same_thread=False)
-            try:
-                yield connection
-            finally:
-                connection.close()
-
-
-def open_agent_session(agent_id: str, path: Path) -> SQLiteSession:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    return _PooledConnectionSession(session_id=agent_id, db_path=path)
-
-
-async def seed_initial_input(session: Session, initial_input: Any) -> bool:
-    """Commit an agent's opening identity/task input before its first run cycle."""
-    items = ItemHelpers.input_to_new_input_list(initial_input)
-    if not items:
-        return False
-    async with session_write_lock(session):
-        if await session.get_items():
-            return False
-        await session.add_items(items)
-    return True
-
-
-_IMAGE_REJECTED_TEXT = "[image rejected by the model]"
-_IMAGE_ELIDED_TEXT = "[older screenshot elided to bound context memory]"
-_INHERITED_IMAGE_TEXT = "[screenshot omitted from inherited context]"
-
-
-def _output_has_image(item_dict: dict[str, Any]) -> bool:
-    return (
-        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"])
-    )
-
-
-def _elided_output(item_dict: dict[str, Any], text: str) -> dict[str, Any]:
-    # Replace only image blocks; sibling text blocks are preserved.
-    output = item_dict.get("output")
-    blocks = output if isinstance(output, list) else []
-    return {
-        "type": "function_call_output",
-        "call_id": item_dict.get("call_id"),
-        "output": [
-            {"type": "input_text", "text": text}
-            if isinstance(block, dict) and block.get("type") == "input_image"
-            else block
-            for block in blocks
-        ],
-    }
-
-
-_session_write_locks: WeakKeyDictionary[Session, asyncio.Lock] = WeakKeyDictionary()
-
-
-def session_write_lock(session: Session) -> asyncio.Lock:
-    """Lock serialising all out-of-band writes to ``session``."""
-    lock = _session_write_locks.get(session)
-    if lock is None:
-        lock = asyncio.Lock()
-        _session_write_locks[session] = lock
-    return lock
-
-
-async def _rewrite_session(
-    session: Session,
-    transform: Callable[[list[Any]], tuple[list[Any], bool]],
-) -> bool:
-    """Read-modify-write a session under its write lock, restoring on failure."""
-    async with session_write_lock(session):
-        items = await session.get_items()
-        if not items:
-            return False
-        rebuilt, changed = transform(list(items))
-        if not changed:
-            return False
-        rebuilt_items = cast("list[TResponseInputItem]", rebuilt)
-        original_items = cast("list[TResponseInputItem]", list(items))
-        await session.clear_session()
-        try:
-            await session.add_items(rebuilt_items)
-        except Exception:
-            logger.exception("session rewrite failed; restoring original items")
-            await session.clear_session()
-            await session.add_items(original_items)
-            raise
-        return True
-
-
-async def replace_session_items(
-    session: Session,
-    new_items: list[Any],
-    *,
-    expected_len: int | None = None,
-) -> bool:
-    """Overwrite the session's items, restoring the originals on failure.
-
-    When ``expected_len`` is given, the rewrite is skipped if the session no
-    longer has that many items (a concurrent writer changed it), so a slow
-    compaction summary can't clobber newer turns.
-    """
-    async with session_write_lock(session):
-        original = list(await session.get_items())
-        if expected_len is not None and len(original) != expected_len:
-            logger.warning(
-                "skipping session rewrite: expected %d items, found %d",
-                expected_len,
-                len(original),
-            )
-            return False
-        rebuilt = cast("list[TResponseInputItem]", new_items)
-        await session.clear_session()
-        try:
-            await session.add_items(rebuilt)
-        except Exception:
-            logger.exception("session rewrite failed; restoring original items")
-            await session.clear_session()
-            await session.add_items(original)
-            raise
-        return True
-
-
-async def strip_all_images_from_session(session: Session) -> bool:
-    """Replace every image tool output with a text placeholder (rejection recovery)."""
-
-    def _transform(items: list[Any]) -> tuple[list[Any], bool]:
-        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 _output_has_image(item_dict):
-                rebuilt.append(_elided_output(item_dict, _IMAGE_REJECTED_TEXT))
-                changed = True
-            else:
-                rebuilt.append(item)
-        return rebuilt, changed
-
-    return await _rewrite_session(session, _transform)
-
-
-async def enforce_image_budget(session: Session, max_images: int) -> bool:
-    """Keep only the most recent ``max_images`` image outputs; elide older ones."""
-    if max_images < 0:
-        return False
-
-    def _transform(items: list[Any]) -> tuple[list[Any], bool]:
-        image_indices = [
-            i
-            for i, item in enumerate(items)
-            if isinstance(item, dict) and _output_has_image(cast("dict[str, Any]", item))
-        ]
-        if len(image_indices) <= max_images:
-            return items, False
-        to_elide = set(image_indices[: len(image_indices) - max_images])
-        rebuilt = [
-            _elided_output(cast("dict[str, Any]", item), _IMAGE_ELIDED_TEXT)
-            if i in to_elide
-            else item
-            for i, item in enumerate(items)
-        ]
-        return rebuilt, True
-
-    return await _rewrite_session(session, _transform)
-
-
-def scrub_images_from_items(items: list[Any]) -> list[Any]:
-    """Return a copy of ``items`` with every image block replaced by text."""
-
-    def _scrub(obj: Any) -> Any:
-        if isinstance(obj, dict):
-            if obj.get("type") == "input_image":
-                return {"type": "input_text", "text": _INHERITED_IMAGE_TEXT}
-            return {k: _scrub(v) for k, v in obj.items()}
-        if isinstance(obj, list):
-            return [_scrub(v) for v in obj]
-        return obj
-
-    return [_scrub(item) for item in items]

strix/interface/assets/tui_styles.tcss

@@ -0,0 +1,690 @@
+Screen {
+    background: #000000;
+    color: #d4d4d4;
+}
+
+.screen--selection {
+    background: #2d3d2f;
+    color: #e5e5e5;
+}
+
+ToastRack {
+    dock: top;
+    align: right top;
+    margin-bottom: 0;
+    margin-top: 1;
+}
+
+Toast {
+    width: 25;
+    background: #000000;
+    border-left: outer #22c55e;
+}
+
+Toast.-information .toast--title {
+    color: #22c55e;
+}
+
+#splash_screen {
+    height: 100%;
+    width: 100%;
+    background: #000000;
+    color: #22c55e;
+    align: center middle;
+    content-align: center middle;
+    text-align: center;
+}
+
+#splash_content {
+    width: auto;
+    height: auto;
+    background: transparent;
+    text-align: center;
+    content-align: center middle;
+    padding: 2;
+}
+
+#main_container {
+    height: 100%;
+    padding: 0;
+    margin: 0;
+    background: #000000;
+}
+
+#content_container {
+    height: 1fr;
+    padding: 0;
+    background: transparent;
+}
+
+#sidebar {
+    width: 20%;
+    background: transparent;
+    margin-left: 1;
+}
+
+#sidebar.-hidden {
+    display: none;
+}
+
+#agents_tree {
+    height: 1fr;
+    background: transparent;
+    border: round #333333;
+    border-title-color: #a8a29e;
+    border-title-style: bold;
+    padding: 1;
+    margin-bottom: 0;
+}
+
+#stats_scroll {
+    height: auto;
+    max-height: 15;
+    background: transparent;
+    padding: 0;
+    margin: 0;
+    border: round #333333;
+    scrollbar-size: 0 0;
+}
+
+#stats_display {
+    height: auto;
+    background: transparent;
+    padding: 0 1;
+    margin: 0;
+}
+
+#vulnerabilities_panel {
+    height: auto;
+    max-height: 12;
+    background: transparent;
+    padding: 0;
+    margin: 0;
+    border: round #333333;
+    overflow-y: auto;
+    scrollbar-background: #000000;
+    scrollbar-color: #333333;
+    scrollbar-corner-color: #000000;
+    scrollbar-size-vertical: 1;
+}
+
+#vulnerabilities_panel.hidden {
+    display: none;
+}
+
+.vuln-item {
+    height: auto;
+    width: 100%;
+    padding: 0 1;
+    background: transparent;
+    color: #d4d4d4;
+}
+
+.vuln-item:hover {
+    background: #1a1a1a;
+    color: #fafaf9;
+}
+
+VulnerabilityDetailScreen {
+    align: center middle;
+    background: #000000 80%;
+}
+
+#vuln_detail_dialog {
+    grid-size: 1;
+    grid-gutter: 1;
+    grid-rows: 1fr auto;
+    padding: 2 3;
+    width: 85%;
+    max-width: 110;
+    height: 85%;
+    max-height: 45;
+    border: solid #262626;
+    background: #0a0a0a;
+}
+
+#vuln_detail_scroll {
+    height: 1fr;
+    background: transparent;
+    scrollbar-background: #0a0a0a;
+    scrollbar-color: #404040;
+    scrollbar-corner-color: #0a0a0a;
+    scrollbar-size: 1 1;
+    padding-right: 1;
+}
+
+#vuln_detail_content {
+    width: 100%;
+    background: transparent;
+    padding: 0;
+}
+
+#vuln_detail_buttons {
+    width: 100%;
+    height: auto;
+    align: right middle;
+    padding-top: 1;
+    margin: 0;
+    border-top: solid #1a1a1a;
+}
+
+#copy_vuln_detail {
+    width: auto;
+    min-width: 12;
+    height: auto;
+    background: transparent;
+    color: #525252;
+    border: none;
+    text-style: none;
+    margin: 0 1;
+    padding: 0 2;
+}
+
+#close_vuln_detail {
+    width: auto;
+    min-width: 10;
+    height: auto;
+    background: transparent;
+    color: #a3a3a3;
+    border: none;
+    text-style: none;
+    margin: 0;
+    padding: 0 2;
+}
+
+#copy_vuln_detail:hover, #copy_vuln_detail:focus {
+    background: transparent;
+    color: #22c55e;
+    border: none;
+}
+
+#close_vuln_detail:hover, #close_vuln_detail:focus {
+    background: transparent;
+    color: #ffffff;
+    border: none;
+}
+
+#chat_area_container {
+    width: 80%;
+    background: transparent;
+}
+
+#chat_area_container.-full-width {
+    width: 100%;
+}
+
+#chat_history {
+    height: 1fr;
+    background: transparent;
+    border: round #0a0a0a;
+    padding: 0;
+    margin-bottom: 0;
+    margin-right: 0;
+    scrollbar-background: #000000;
+    scrollbar-color: #1a1a1a;
+    scrollbar-corner-color: #000000;
+    scrollbar-size: 1 1;
+}
+
+#agent_status_display {
+    height: 1;
+    background: transparent;
+    margin: 0;
+    padding: 0 1;
+}
+
+#agent_status_display.hidden {
+    display: none;
+}
+
+#status_text {
+    width: 1fr;
+    height: 100%;
+    background: transparent;
+    color: #a3a3a3;
+    text-align: left;
+    content-align: left middle;
+    text-style: none;
+    margin: 0;
+    padding: 0;
+}
+
+#keymap_indicator {
+    width: auto;
+    height: 100%;
+    background: transparent;
+    color: #737373;
+    text-align: right;
+    content-align: right middle;
+    text-style: none;
+    margin: 0;
+    padding: 0;
+}
+
+#chat_input_container {
+    height: 3;
+    background: transparent;
+    border: round #333333;
+    margin-right: 0;
+    padding: 0;
+    layout: horizontal;
+    align-vertical: top;
+}
+
+#chat_input_container:focus-within {
+    border: round #22c55e;
+}
+
+#chat_input_container:focus-within #chat_prompt {
+    color: #22c55e;
+    text-style: bold;
+}
+
+#chat_prompt {
+    width: auto;
+    height: 100%;
+    padding: 0 0 0 1;
+    color: #737373;
+    content-align-vertical: top;
+}
+
+#chat_history:focus {
+    border: round #22c55e;
+}
+
+#chat_input {
+    width: 1fr;
+    height: 100%;
+    background: transparent;
+    border: none;
+    color: #d4d4d4;
+    padding: 0;
+    margin: 0;
+}
+
+#chat_input:focus {
+    border: none;
+}
+
+#chat_input .text-area--cursor-line {
+    background: transparent;
+}
+
+#chat_input:focus .text-area--cursor-line {
+    background: transparent;
+}
+
+#chat_input > .text-area--placeholder {
+    color: #525252;
+    text-style: italic;
+}
+
+#chat_input > .text-area--cursor {
+    color: #22c55e;
+    background: #22c55e;
+}
+
+.chat-placeholder {
+    width: 100%;
+    height: 100%;
+    content-align: center middle;
+    text-align: center;
+    color: #737373;
+    text-style: italic;
+}
+
+.chat-content {
+    margin: 0 !important;
+    margin-top: 0 !important;
+    margin-bottom: 0 !important;
+    padding: 0 1;
+    background: transparent;
+    width: 100%;
+}
+
+.chat-message {
+    margin-bottom: 0;
+    padding: 0;
+    background: transparent;
+    width: 100%;
+}
+
+.user-message {
+    color: #e5e5e5;
+    border-left: thick #3b82f6;
+    padding-left: 1;
+    margin-bottom: 1;
+}
+
+.tool-call {
+    margin-top: 1;
+    margin-bottom: 0;
+    padding: 0 1;
+    background: transparent;
+    border: none;
+    width: 100%;
+}
+
+.tool-call.status-completed {
+    background: transparent;
+    margin-top: 1;
+    margin-bottom: 0;
+}
+
+.tool-call.status-running {
+    background: transparent;
+    margin-top: 1;
+    margin-bottom: 0;
+}
+
+.tool-call.status-failed,
+.tool-call.status-error {
+    background: transparent;
+    margin-top: 1;
+    margin-bottom: 0;
+}
+
+.browser-tool,
+.terminal-tool,
+.python-tool,
+.agents-graph-tool,
+.file-edit-tool,
+.proxy-tool,
+.notes-tool,
+.thinking-tool,
+.web-search-tool,
+.scan-info-tool,
+.subagent-info-tool {
+    margin-top: 1;
+    margin-bottom: 0;
+    background: transparent;
+}
+
+.finish-tool,
+.reporting-tool {
+    margin-top: 1;
+    margin-bottom: 0;
+    background: transparent;
+}
+
+.browser-tool.status-completed,
+.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,
+.file-edit-tool.status-running,
+.proxy-tool.status-completed,
+.proxy-tool.status-running,
+.notes-tool.status-completed,
+.notes-tool.status-running,
+.thinking-tool.status-completed,
+.thinking-tool.status-running,
+.web-search-tool.status-completed,
+.web-search-tool.status-running,
+.scan-info-tool.status-completed,
+.scan-info-tool.status-running,
+.subagent-info-tool.status-completed,
+.subagent-info-tool.status-running {
+    background: transparent;
+    margin-top: 1;
+    margin-bottom: 0;
+}
+
+.finish-tool.status-completed,
+.finish-tool.status-running,
+.reporting-tool.status-completed,
+.reporting-tool.status-running {
+    background: transparent;
+    margin-top: 1;
+    margin-bottom: 0;
+}
+
+Tree {
+    background: transparent;
+    color: #e7e5e4;
+    scrollbar-background: transparent;
+    scrollbar-color: #404040;
+    scrollbar-corner-color: transparent;
+    scrollbar-size: 1 1;
+}
+
+Tree > .tree--label {
+    text-style: bold;
+    color: #a8a29e;
+    background: transparent;
+    padding: 0 1;
+    margin-bottom: 1;
+    border-bottom: solid #1a1a1a;
+    text-align: center;
+}
+
+.tree--node {
+    height: 1;
+    padding: 0;
+    margin: 0;
+}
+
+.tree--node-label {
+    color: #d6d3d1;
+    background: transparent;
+    text-style: none;
+    padding: 0 1;
+    margin: 0 1;
+}
+
+.tree--node:hover .tree--node-label {
+    background: transparent;
+    color: #fafaf9;
+    text-style: bold;
+    border-left: solid #a8a29e;
+}
+
+.tree--node.-selected .tree--node-label {
+    background: transparent;
+    color: #fafaf9;
+    text-style: bold;
+    border-left: heavy #d6d3d1;
+}
+
+.tree--node.-expanded .tree--node-label {
+    text-style: bold;
+    color: #fafaf9;
+    background: transparent;
+    border-left: solid #78716c;
+}
+
+Tree:focus {
+    border: round #1a1a1a;
+}
+
+Tree:focus > .tree--label {
+    color: #fafaf9;
+    text-style: bold;
+    background: transparent;
+}
+
+.tree--node .tree--node .tree--node-label {
+    color: #a8a29e;
+    padding-left: 2;
+    border: none;
+    background: transparent;
+    margin-left: 1;
+}
+
+.tree--node .tree--node:hover .tree--node-label {
+    background: transparent;
+    color: #e7e5e4;
+}
+
+.tree--node .tree--node .tree--node .tree--node-label {
+    color: #78716c;
+    padding-left: 3;
+    text-style: none;
+    border: none;
+    background: transparent;
+    margin-left: 2;
+}
+
+StopAgentScreen {
+    align: center middle;
+    background: $background 0%;
+}
+
+#stop_agent_dialog {
+    grid-size: 1;
+    grid-gutter: 1;
+    grid-rows: auto auto;
+    padding: 1;
+    width: 30;
+    height: auto;
+    border: round #a3a3a3;
+    background: #000000 98%;
+}
+
+#stop_agent_title {
+    color: #a3a3a3;
+    text-style: bold;
+    text-align: center;
+    width: 100%;
+    margin-bottom: 0;
+}
+
+#stop_agent_buttons {
+    grid-size: 2;
+    grid-gutter: 1;
+    grid-columns: 1fr 1fr;
+    width: 100%;
+    height: 1;
+}
+
+#stop_agent_buttons Button {
+    height: 1;
+    min-height: 1;
+    border: none;
+    text-style: bold;
+}
+
+#stop_agent {
+    background: transparent;
+    color: #ef4444;
+    border: none;
+}
+
+#stop_agent:hover, #stop_agent:focus {
+    background: #ef4444;
+    color: #ffffff;
+    border: none;
+}
+
+#cancel_stop {
+    background: transparent;
+    color: #737373;
+    border: none;
+}
+
+#cancel_stop:hover, #cancel_stop:focus {
+    background:rgb(54, 54, 54);
+    color: #ffffff;
+    border: none;
+}
+
+QuitScreen {
+    align: center middle;
+    background: $background 0%;
+}
+
+#quit_dialog {
+    grid-size: 1;
+    grid-gutter: 1;
+    grid-rows: auto auto;
+    padding: 1;
+    width: 24;
+    height: auto;
+    border: round #333333;
+    background: #000000 98%;
+}
+
+#quit_title {
+    color: #d4d4d4;
+    text-style: bold;
+    text-align: center;
+    width: 100%;
+    margin-bottom: 0;
+}
+
+#quit_buttons {
+    grid-size: 2;
+    grid-gutter: 1;
+    grid-columns: 1fr 1fr;
+    width: 100%;
+    height: 1;
+}
+
+#quit_buttons Button {
+    height: 1;
+    min-height: 1;
+    border: none;
+    text-style: bold;
+}
+
+#quit {
+    background: transparent;
+    color: #ef4444;
+    border: none;
+}
+
+#quit:hover, #quit:focus {
+    background: #ef4444;
+    color: #ffffff;
+    border: none;
+}
+
+#cancel {
+    background: transparent;
+    color: #737373;
+    border: none;
+}
+
+#cancel:hover, #cancel:focus {
+    background:rgb(54, 54, 54);
+    color: #ffffff;
+    border: none;
+}
+
+HelpScreen {
+    align: center middle;
+    background: $background 0%;
+}
+
+#dialog {
+    grid-size: 1;
+    grid-gutter: 0 1;
+    grid-rows: auto auto;
+    padding: 1 2;
+    width: 40;
+    height: auto;
+    border: round #22c55e;
+    background: #000000 98%;
+}
+
+#help_title {
+    color: #22c55e;
+    text-style: bold;
+    text-align: center;
+    width: 100%;
+    margin-bottom: 1;
+}
+
+#help_content {
+    color: #d4d4d4;
+    text-align: left;
+    width: 100%;
+    margin-bottom: 1;
+    padding: 0;
+    background: transparent;
+    text-style: none;
+}

strix/interface/auth_cli.py

@@ -1,419 +0,0 @@
-"""`strix auth` — ChatGPT subscription sign-in (login / status / logout).
-
-Signing in only stores OAuth tokens (``~/.strix/subscription-auth.json``); model
-selection stays with ``STRIX_LLM``. A ``chatgpt/<model>`` STRIX_LLM runs on the
-subscription.
-"""
-
-from __future__ import annotations
-
-import argparse
-import base64
-import logging
-import threading
-import webbrowser
-from http.server import BaseHTTPRequestHandler, HTTPServer
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-from urllib.parse import parse_qs, urlparse
-
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-
-from strix.config import codex, load_settings
-
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-
-logger = logging.getLogger(__name__)
-
-_CALLBACK_TIMEOUT_S = 300
-
-# CLI-facing name for the login provider. Internally this is the Codex OAuth
-# flow (``codex.PROVIDER``), but users know it as ChatGPT, so that's what the
-# command and messaging say. ``codex`` is accepted as an alias.
-LOGIN_PROVIDER = "chatgpt"
-_ACCEPTED_PROVIDERS = frozenset({LOGIN_PROVIDER, codex.PROVIDER})
-
-_USAGE = "Usage:\n  strix auth login chatgpt [--manual]\n  strix auth status\n  strix auth logout"
-
-
-def run_auth(argv: list[str]) -> int:
-    """Entry point for ``strix auth …``. Returns a process exit code."""
-    console = Console()
-    # Bare `strix auth` (no subcommand) defaults to login.
-    subcommand = argv[0] if argv else "login"
-    rest = argv[1:]
-
-    if subcommand in ("-h", "--help", "help"):
-        console.print(_USAGE)
-        return 0
-
-    handlers: dict[str, Callable[[], int]] = {
-        "login": lambda: _login(console, rest),
-        "status": lambda: _status(console),
-        "logout": lambda: _logout(console),
-    }
-    handler = handlers.get(subcommand)
-    if handler is not None:
-        return handler()
-
-    console.print(f"[red]Unknown auth command:[/] {subcommand}\n")
-    console.print(_USAGE)
-    return 2
-
-
-def _login(console: Console, argv: list[str]) -> int:
-    parser = argparse.ArgumentParser(prog="strix auth login", add_help=True)
-    parser.add_argument(
-        "provider",
-        nargs="?",
-        default=LOGIN_PROVIDER,
-        help="Model provider to sign in with (default: chatgpt).",
-    )
-    parser.add_argument(
-        "--manual",
-        action="store_true",
-        help="Skip the local callback server and paste the redirect URL by hand.",
-    )
-    try:
-        args = parser.parse_args(argv)
-    except SystemExit as exc:  # argparse already printed the message
-        return int(exc.code or 2)
-
-    if args.provider.lower() not in _ACCEPTED_PROVIDERS:
-        console.print(
-            f"[red]Unsupported provider:[/] {args.provider}. "
-            f"Only '{LOGIN_PROVIDER}' (ChatGPT subscription) is supported."
-        )
-        return 2
-
-    verifier, challenge = codex.generate_pkce()
-    state = codex.create_state()
-    authorize_url = codex.build_authorize_url(challenge, state)
-
-    console.print()
-    console.print("[bold]Signing in with ChatGPT[/] [dim](provider: chatgpt)[/]")
-    console.print(
-        "[dim]This uses your ChatGPT Plus/Pro plan for inference instead of a metered API key.[/]"
-    )
-    console.print()
-
-    try:
-        record = _run_oauth_flow(console, authorize_url, verifier, state, manual=args.manual)
-    except codex.CodexAuthError as exc:
-        return _fail(console, exc)
-    except KeyboardInterrupt:
-        console.print("\n[yellow]Sign-in cancelled.[/]")
-        return 130
-
-    codex.save_record(record)
-    _print_success(console)
-    return 0
-
-
-def _run_oauth_flow(
-    console: Console,
-    authorize_url: str,
-    verifier: str,
-    state: str,
-    *,
-    manual: bool,
-) -> dict[str, Any]:
-    """Drive the browser (or manual) OAuth flow and return a token record."""
-    server = None if manual else _try_start_callback_server()
-
-    console.print("Open this URL in your browser to authorize:")
-    console.print(f"[cyan]{authorize_url}[/]")
-    console.print()
-    if not manual:
-        try:
-            webbrowser.open(authorize_url)
-        except Exception:  # noqa: BLE001 - opening a browser is best-effort
-            logger.debug("could not open browser", exc_info=True)
-
-    if server is not None:
-        console.print("[dim]Waiting for you to finish signing in…[/]")
-        result = server.wait(_CALLBACK_TIMEOUT_S)
-        server.shutdown()
-        if result is not None:
-            code, returned_state, error = result
-            if error:
-                raise codex.CodexAuthError("oauth_error", error)
-            return _finish(code, returned_state, verifier, state, require_state=True)
-        console.print("[yellow]Timed out waiting for the browser. Falling back to manual paste.[/]")
-
-    # Manual fallback: the user completes sign-in and pastes the redirect URL
-    # (the browser lands on a localhost page that won't load if no server is up;
-    # the address bar still holds the code+state).
-    console.print()
-    try:
-        pasted = console.input("Paste the full redirect URL (or code#state): ").strip()
-    except EOFError as exc:
-        raise codex.CodexAuthError("no_input", "no redirect URL provided") from exc
-    code, returned_state = codex.parse_redirect_input(pasted)
-    return _finish(code, returned_state, verifier, state, require_state=False)
-
-
-def _finish(
-    code: str | None,
-    returned_state: str | None,
-    verifier: str,
-    expected_state: str,
-    *,
-    require_state: bool,
-) -> dict[str, Any]:
-    if not code:
-        raise codex.CodexAuthError("no_code", "no authorization code found in the redirect")
-    # The loopback callback from OpenAI always carries state, so a missing or
-    # mismatched value there is forged (CSRF) and must be rejected. Manual paste
-    # is user-initiated (the user copies their own redirect), so state is only
-    # validated when the pasted value includes it.
-    if require_state and returned_state is None:
-        raise codex.CodexAuthError("state_mismatch", "missing state in callback; possible CSRF")
-    if returned_state is not None and returned_state != expected_state:
-        raise codex.CodexAuthError("state_mismatch", "state did not match; possible CSRF")
-    return codex.exchange_code(code, verifier)
-
-
-class _CallbackServer:
-    """A one-shot local HTTP server that catches the OAuth redirect."""
-
-    def __init__(self, httpd: HTTPServer, event: threading.Event, holder: dict[str, Any]) -> None:
-        self._httpd = httpd
-        self._event = event
-        self._holder = holder
-        self._thread = threading.Thread(target=httpd.serve_forever, daemon=True)
-        self._thread.start()
-
-    def wait(self, timeout: float) -> tuple[str | None, str | None, str | None] | None:
-        if not self._event.wait(timeout):
-            return None
-        return (
-            self._holder.get("code"),
-            self._holder.get("state"),
-            self._holder.get("error"),
-        )
-
-    def shutdown(self) -> None:
-        self._httpd.shutdown()
-        self._httpd.server_close()
-
-
-def _try_start_callback_server() -> _CallbackServer | None:
-    event = threading.Event()
-    holder: dict[str, Any] = {}
-
-    class Handler(BaseHTTPRequestHandler):
-        def log_message(self, *args: Any) -> None:  # silence default stderr logging
-            pass
-
-        def do_GET(self) -> None:
-            parsed = urlparse(self.path)
-            if parsed.path != codex.CALLBACK_PATH:
-                self.send_response(404)
-                self.end_headers()
-                return
-            query = parse_qs(parsed.query)
-            holder["code"] = _first(query, "code")
-            holder["state"] = _first(query, "state")
-            holder["error"] = _first(query, "error_description") or _first(query, "error")
-            body = _render_callback_html().encode("utf-8")
-            self.send_response(200)
-            self.send_header("Content-Type", "text/html; charset=utf-8")
-            self.send_header("Content-Length", str(len(body)))
-            self.end_headers()
-            self.wfile.write(body)
-            event.set()
-
-    try:
-        httpd = HTTPServer(("127.0.0.1", codex.CALLBACK_PORT), Handler)
-    except OSError:
-        logger.debug("could not bind callback port %d", codex.CALLBACK_PORT, exc_info=True)
-        return None
-    return _CallbackServer(httpd, event, holder)
-
-
-def _first(query: dict[str, list[str]], key: str) -> str | None:
-    values = query.get(key)
-    return values[0] if values else None
-
-
-def _status(console: Console) -> int:
-    record = codex.read_record()
-    if record is None:
-        console.print("[yellow]Not signed in.[/] Run [cyan]strix auth login chatgpt[/] to sign in.")
-        return 1
-    settings = load_settings()
-    console.print("[green]Signed in[/] with a ChatGPT subscription.")
-    console.print(f"  Account: [bold]{record.get('account_id')}[/]")
-    if codex.subscription_model(settings.llm.model):
-        console.print(f"  Runs use the subscription (STRIX_LLM=[bold]{settings.llm.model}[/]).")
-    else:
-        console.print(
-            "  [yellow]Note:[/] set [cyan]STRIX_LLM[/] to e.g. [cyan]chatgpt/gpt-5.4[/] "
-            "to run on the subscription."
-        )
-    return 0
-
-
-def _logout(console: Console) -> int:
-    codex.logout()
-    console.print("[green]Signed out.[/] Stored subscription credentials removed.")
-    return 0
-
-
-def _fail(console: Console, exc: codex.CodexAuthError) -> int:
-    error_text = Text()
-    error_text.append("SIGN-IN FAILED", style="bold red")
-    error_text.append("\n\n", style="white")
-    error_text.append(f"{exc}", style="white")
-    console.print()
-    console.print(
-        Panel(
-            error_text,
-            title="[bold white]STRIX",
-            title_align="left",
-            border_style="red",
-            padding=(1, 2),
-        )
-    )
-    return 1
-
-
-def _print_success(console: Console) -> None:
-    text = Text()
-    text.append("Signed in with your ChatGPT subscription", style="bold #22c55e")
-    text.append("\n\n", style="white")
-    text.append("Set ", style="white")
-    text.append("STRIX_LLM", style="bold white")
-    text.append(" to a ", style="white")
-    text.append("chatgpt/", style="bold cyan")
-    text.append(" model (e.g. ", style="white")
-    text.append("chatgpt/gpt-5.4", style="bold cyan")
-    text.append(") — runs are billed to your ChatGPT plan.", style="white")
-    text.append("\n\n", style="white")
-    text.append("Run a scan as usual, e.g. ", style="white")
-    text.append("strix --target https://example.com", style="bold cyan")
-    console.print()
-    console.print(
-        Panel(
-            text,
-            title="[bold white]STRIX",
-            title_align="left",
-            border_style="#22c55e",
-            padding=(1, 2),
-        )
-    )
-    console.print()
-
-
-_LOGO_PATH = Path(__file__).resolve().parent.parent / "viewer" / "static" / "logo.png"
-
-
-def _logo_img_tag() -> str:
-    """Return an ``<img>`` for the Strix logo as an inline data URI, or "".
-
-    The callback page is served offline by the local OAuth server, so the logo
-    is embedded rather than linked. Missing/unreadable file degrades to just the
-    "Strix" wordmark.
-    """
-    try:
-        data = _LOGO_PATH.read_bytes()
-    except OSError:
-        return ""
-    encoded = base64.b64encode(data).decode("ascii")
-    return f'<img class="logo" src="data:image/png;base64,{encoded}" alt="" />'
-
-
-def _render_callback_html() -> str:
-    return _CALLBACK_HTML.replace("<!--LOGO-->", _logo_img_tag())
-
-
-_CALLBACK_HTML = """<!doctype html>
-<html lang="en"><head><meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>Strix — signed in</title>
-<style>
-  :root { color-scheme: dark; }
-  * { box-sizing: border-box; }
-  body {
-    margin: 0; min-height: 100vh; padding: 24px;
-    font-family: 'Geist', 'Geist Sans', ui-sans-serif, system-ui, -apple-system,
-      "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
-    -webkit-font-smoothing: antialiased; -moz-osx-font-smoothing: grayscale;
-    background: #000; color: #ededed;
-    display: flex; flex-direction: column; align-items: center; justify-content: center;
-  }
-  .topbar {
-    position: absolute; top: 20px; left: 22px;
-    display: flex; align-items: center; gap: 6px; text-decoration: none;
-  }
-  .topbar .logo { width: 40px; height: 40px; display: block; }
-  .topbar span {
-    font-size: 1.1rem; font-weight: 600; letter-spacing: -.01em; color: #fff;
-    transition: color .15s ease;
-  }
-  .topbar:hover span { color: #c9c9c9; }
-  .brand {
-    font-size: 2.1rem; font-weight: 700; letter-spacing: -.02em; color: #fff;
-    text-align: center; margin: 0 0 10px;
-  }
-  h1 {
-    font-size: 1.35rem; font-weight: 600; letter-spacing: -.01em; color: #f5f5f5;
-    text-align: center; margin: 0 0 28px;
-  }
-  .card {
-    width: 100%; max-width: 430px; text-align: center;
-    background: #171717; border: 1px solid rgba(255, 255, 255, .06);
-    border-radius: 24px; padding: 40px 40px 34px;
-  }
-  .badge {
-    margin: 0 auto 22px; width: 52px; height: 52px; border-radius: 50%;
-    display: flex; align-items: center; justify-content: center; font-size: 23px; color: #fff;
-    background: rgba(255, 255, 255, .05); border: 1px solid rgba(255, 255, 255, .14);
-  }
-  .msg { margin: 0 auto; max-width: 34ch; color: #b5b5b5; line-height: 1.6; font-size: .98rem; }
-  .rule { height: 1px; background: rgba(255, 255, 255, .07); margin: 26px 0 0; }
-  .tagline { margin: 22px 0 0; color: #7c7c7c; font-size: .9rem; line-height: 1.55; }
-  .tagline b { color: #ededed; font-weight: 500; }
-  .links {
-    margin-top: 18px; display: flex; gap: 8px; justify-content: center;
-    align-items: center; flex-wrap: wrap; font-size: .84rem;
-  }
-  .links a { color: #a3a3a3; text-decoration: none; transition: color .15s ease; }
-  .links a:hover { color: #fff; }
-  .links .dot { color: #3a3a3a; }
-  .close { margin: 24px 0 0; color: #5a5a5a; font-size: .78rem; text-align: center; }
-</style></head>
-<body>
-  <a class="topbar" href="https://strix.ai" target="_blank" rel="noopener"
-     aria-label="Strix — strix.ai">
-    <!--LOGO-->
-    <span>Strix</span>
-  </a>
-  <div class="brand">Strix</div>
-  <h1>You're signed in</h1>
-  <main class="card">
-    <div class="badge">✓</div>
-    <p class="msg">Strix is connected to your ChatGPT subscription. Head back to your
-      terminal — your security test runs there.</p>
-    <div class="rule"></div>
-    <p class="tagline">Autonomous AI hackers that <b>find and fix</b> your app's
-      vulnerabilities.</p>
-    <nav class="links">
-      <a href="https://strix.ai" target="_blank" rel="noopener">strix.ai</a>
-      <span class="dot">·</span>
-      <a href="https://docs.strix.ai" target="_blank" rel="noopener">docs</a>
-      <span class="dot">·</span>
-      <a href="https://discord.gg/strix-ai" target="_blank" rel="noopener">community</a>
-    </nav>
-  </main>
-  <p class="close">You can close this tab.</p>
-</body></html>"""
-
-
-__all__ = ["run_auth"]

strix/interface/cli.py

@@ -1,6 +1,4 @@
 import atexit
-import contextlib
-import logging
 import signal
 import sys
 import threading
@@ -12,31 +10,16 @@ from rich.live import Live
 from rich.panel import Panel
 from rich.text import Text
 
-from strix.config import load_settings
-from strix.config.settings import DEFAULT_MAX_TURNS
-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,
     format_vulnerability_report,
-    has_model_response,
 )
 
 
-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()
 
@@ -84,24 +67,28 @@ 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,
+        is_whitebox=bool(getattr(args, "local_sources", [])),
+    )
+    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")
@@ -119,13 +106,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)
@@ -134,20 +124,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)
-
-    startup_phase: list[str] = ["Starting up"]
+    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")
 
-        if not has_model_response(report_state):
-            status_text.append(f"{startup_phase[0]}...", style="dim")
-            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)
 
@@ -159,9 +143,6 @@ async def run_cli(args: Any) -> None:  # noqa: PLR0915
             padding=(1, 2),
         )
 
-    def _note_startup_phase(phase: str) -> None:
-        startup_phase[:] = [phase]
-
     try:
         console.print()
 
@@ -175,40 +156,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),
-                    max_turns=getattr(args, "max_turns", DEFAULT_MAX_TURNS),
-                    status_sink=_note_startup_phase,
-                )
+                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()
@@ -218,7 +193,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/cli_args.py

@@ -1,380 +0,0 @@
-"""Command-line argument parsing for the ``strix`` scan entrypoint."""
-
-from __future__ import annotations
-
-import argparse
-import sys
-from pathlib import Path
-
-from strix.config import apply_config_override
-from strix.config.settings import DEFAULT_MAX_TURNS
-from strix.core.paths import run_dir_for, runtime_state_dir
-from strix.interface.scan_setup import attach_workspace_mount, build_targets_info
-from strix.interface.update_check import self_update
-from strix.interface.utils import (
-    check_mountable_dir,
-    collect_local_sources,
-    validate_config_file,
-)
-
-
-def get_version() -> str:
-    try:
-        from importlib.metadata import version
-
-        return version("strix-agent")
-    except Exception:
-        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 _positive_int(value: str) -> int:
-    try:
-        parsed = int(value)
-    except ValueError as exc:
-        raise argparse.ArgumentTypeError(f"invalid int value: {value!r}") from exc
-    if parsed <= 0:
-        raise argparse.ArgumentTypeError("must be an integer greater than 0")
-    return parsed
-
-
-def parse_arguments() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Strix Multi-Agent Cybersecurity Penetration Testing Tool",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Web application penetration test
-  strix --target https://example.com
-
-  # GitHub repository analysis
-  strix --target https://github.com/user/repo
-  strix --target git@github.com:user/repo.git
-
-  # Local code analysis
-  strix --target ./my-project
-
-  # API spec test (OpenAPI/Swagger file or Postman collection export)
-  strix --target ./openapi.yaml --target https://api.example.com
-  strix --target ./collection.postman_collection.json
-
-  # Postman collection pulled live by id (needs POSTMAN_API_KEY); optional environment
-  strix --target postman://<collection-uuid> --target https://api.example.com
-  strix --target "postman://<collection-uuid>?env=<environment-uuid>"
-
-  # Domain penetration test
-  strix --target example.com
-
-  # IP address penetration test
-  strix --target 192.168.1.42
-
-  # Multiple targets (e.g., white-box testing with source and deployed app)
-  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"
-
-  # Custom instructions (from file)
-  strix --target example.com --instruction-file ./instructions.txt
-  strix --target https://app.com --instruction-file /path/to/detailed_instructions.md
-        """,
-    )
-
-    parser.add_argument(
-        "-v",
-        "--version",
-        action="version",
-        version=f"strix {get_version()}",
-    )
-
-    parser.add_argument(
-        "--update",
-        action="store_true",
-        help="Update strix to the latest version and exit. Self-updates the "
-        "standalone binary install; for pip/pipx/uv installs, prints the "
-        "matching upgrade command instead.",
-    )
-
-    parser.add_argument(
-        "-t",
-        "--target",
-        type=str,
-        action="append",
-        help="Target to test: URL, repository, local directory path, domain name, IP address, "
-        "an API spec file (OpenAPI/Swagger .json/.yaml or a Postman collection export), or a "
-        "Postman collection by id (postman://<collection-uuid>[?env=<environment-uuid>], needs "
-        "POSTMAN_API_KEY). Local directories are mounted into the sandbox writable. "
-        "Can be specified multiple times for multi-target scans. "
-        "Fresh runs require --target or --target-list.",
-    )
-    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(
-        "--instruction",
-        type=str,
-        help="Custom instructions for the penetration test. This can be "
-        "specific vulnerability types to focus on (e.g., 'Focus on IDOR and XSS'), "
-        "testing approaches (e.g., 'Perform thorough authentication testing'), "
-        "test credentials (e.g., 'Use the following credentials to access the app: "
-        "admin:password123'), "
-        "or areas of interest (e.g., 'Check login API endpoint for security issues').",
-    )
-
-    parser.add_argument(
-        "--instruction-file",
-        type=str,
-        help="Path to a file containing detailed custom instructions for the penetration test. "
-        "Use this option when you have lengthy or complex instructions saved in a file "
-        "(e.g., '--instruction-file ./detailed_instructions.txt').",
-    )
-
-    parser.add_argument(
-        "-n",
-        "--non-interactive",
-        action="store_true",
-        help=(
-            "Run in non-interactive mode (no TUI, exits on completion). "
-            "Default is interactive mode with TUI."
-        ),
-    )
-
-    parser.add_argument(
-        "-m",
-        "--scan-mode",
-        type=str,
-        choices=["quick", "standard", "deep"],
-        default="deep",
-        help=(
-            "Scan mode: "
-            "'quick' for fast CI/CD checks, "
-            "'standard' for routine testing, "
-            "'deep' for thorough security reviews (default). "
-            "Default: deep."
-        ),
-    )
-
-    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",
-        "--max-budget-usd",
-        dest="max_budget_usd",
-        metavar="USD",
-        type=_positive_budget,
-        default=None,
-        help=(
-            "Maximum LLM cost in USD (> 0). The scan stops cleanly when this limit is reached. "
-            "Graduated wrap-up warnings are sent to all agents as it is approached."
-        ),
-    )
-
-    parser.add_argument(
-        "--max-turns",
-        dest="max_turns",
-        metavar="N",
-        type=_positive_int,
-        default=DEFAULT_MAX_TURNS,
-        help=(
-            "Maximum turns per agent (> 0, default %(default)s). Each agent is force-stopped "
-            "when it reaches this limit, with graduated wrap-up warnings as it is approached."
-        ),
-    )
-
-    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()
-    # Startup-resolved state lives alongside the parsed flags. The full schema
-    # is established here so downstream code reads attributes directly.
-    args.needs_setup = False
-    args.targets_info = []
-    args.local_sources = []
-    args.diff_scope = {"active": False}
-    args.run_name = None
-
-    if args.config:
-        apply_config_override(validate_config_file(args.config))
-
-    if args.update:
-        sys.exit(0 if self_update() else 1)
-
-    if args.instruction and args.instruction_file:
-        parser.error(
-            "Cannot specify both --instruction and --instruction-file. Use one or the other."
-        )
-
-    if args.instruction_file:
-        instruction_path = Path(args.instruction_file)
-        try:
-            with instruction_path.open(encoding="utf-8") as f:
-                args.instruction = f.read().strip()
-                if not args.instruction:
-                    parser.error(f"Instruction file '{instruction_path}' is empty")
-        except Exception as e:
-            parser.error(f"Failed to read instruction file '{instruction_path}': {e}")
-
-    args.user_explicit_instruction = args.instruction if args.resume else None
-    # What the user actually asked for, kept apart from args.instruction because
-    # prepare_run prepends the diff-scope preamble to that. This is the text the
-    # transcript shows as their opening message.
-    args.user_instruction = args.instruction or None
-
-    if args.resume:
-        if args.target or args.target_list:
-            parser.error(
-                "Cannot combine --resume with --target/--target-list. "
-                "--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:
-            if args.non_interactive:
-                parser.error(
-                    "the following arguments are required: -t/--target or --target-list "
-                    "(or use --resume <run_name> to continue a prior scan)"
-                )
-            # Interactive launch with no target: open the normal TUI on its
-            # start screen, where the user gives a target or a bare prompt
-            # before the scan starts.
-            args.needs_setup = True
-            return args
-
-        try:
-            build_targets_info(args)
-        except ValueError as e:
-            parser.error(str(e))
-
-    return args
-
-
-def _load_resume_state(args: argparse.Namespace, parser: argparse.ArgumentParser) -> None:
-    """Populate ``args.targets_info`` and friends from a prior run's run.json."""
-    from strix.report.writer import read_run_record
-
-    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 []
-    # A target-less run has no targets_info at all. It is driven by its
-    # instruction, over a mounted working directory or over nothing when the
-    # mount was declined, so either of those is enough to resume it.
-    workspace_mount = state.get("workspace_mount") or None
-    if not args.targets_info and not workspace_mount and not state.get("user_instruction"):
-        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") == "local_code" and details.get("target_path"):
-            try:
-                check_mountable_dir(Path(details["target_path"]).expanduser())
-            except ValueError as exc:
-                parser.error(f"--resume {args.resume}: {exc}")
-            continue
-        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 not getattr(args, "user_instruction", None):
-        args.user_instruction = state.get("user_instruction") or None
-    args.local_sources = collect_local_sources(args.targets_info)
-    # Remount the workspace the run was started with. The user already confirmed
-    # this directory, so the target mount guard does not apply to it; it only has
-    # to still be there.
-    args.workspace_mount = workspace_mount
-    if workspace_mount:
-        if not Path(workspace_mount).expanduser().is_dir():
-            parser.error(
-                f"--resume {args.resume}: the working directory {workspace_mount} "
-                f"is missing. Restore it before resuming, or start a fresh run."
-            )
-        attach_workspace_mount(args)
-    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

strix/interface/environment.py

@@ -1,217 +0,0 @@
-"""Startup environment validation and Docker image management."""
-
-import logging
-import shutil
-import sys
-
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-
-from strix.config import codex, load_settings
-from strix.interface.utils import (
-    check_docker_connection,
-    image_exists,
-    process_pull_line,
-)
-
-
-logger = logging.getLogger(__name__)
-
-
-def validate_environment() -> None:
-    logger.info("Validating environment")
-    console = Console()
-    missing_required_vars = []
-    missing_optional_vars = []
-
-    settings = load_settings()
-
-    if codex.subscription_model(settings.llm.model):
-        if not codex.is_authenticated():
-            console.print(
-                f"[red]STRIX_LLM={settings.llm.model} uses your ChatGPT subscription, "
-                "but you're not signed in.[/] Run [cyan]strix auth login chatgpt[/] first."
-            )
-            sys.exit(1)
-        logger.info("Environment OK (ChatGPT subscription)")
-        return
-
-    if not settings.llm.model:
-        missing_required_vars.append("STRIX_LLM")
-
-    if not settings.llm.api_key:
-        missing_optional_vars.append("LLM_API_KEY")
-
-    if not settings.llm.api_base:
-        missing_optional_vars.append("LLM_API_BASE")
-
-    if not settings.integrations.perplexity_api_key:
-        missing_optional_vars.append("PERPLEXITY_API_KEY")
-
-    if missing_required_vars:
-        error_text = Text()
-        error_text.append("MISSING REQUIRED ENVIRONMENT VARIABLES", style="bold red")
-        error_text.append("\n\n", style="white")
-
-        for var in missing_required_vars:
-            error_text.append(f"• {var}", style="bold yellow")
-            error_text.append(" is not set\n", style="white")
-
-        if missing_optional_vars:
-            error_text.append("\nOptional environment variables:\n", style="dim white")
-            for var in missing_optional_vars:
-                error_text.append(f"• {var}", style="dim yellow")
-                error_text.append(" is not set\n", style="dim white")
-
-        error_text.append("\nRequired environment variables:\n", style="white")
-        for var in missing_required_vars:
-            if var == "STRIX_LLM":
-                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",
-                    style="white",
-                )
-
-        if missing_optional_vars:
-            error_text.append("\nOptional environment variables:\n", style="white")
-            for var in missing_optional_vars:
-                if var == "LLM_API_BASE":
-                    error_text.append("• ", style="white")
-                    error_text.append("LLM_API_BASE", style="bold cyan")
-                    error_text.append(
-                        " - Custom API base URL if using local models (e.g., Ollama, LMStudio)\n",
-                        style="white",
-                    )
-                elif var == "PERPLEXITY_API_KEY":
-                    error_text.append("• ", style="white")
-                    error_text.append("PERPLEXITY_API_KEY", style="bold cyan")
-                    error_text.append(
-                        " - API key for Perplexity AI web search (enables real-time research)\n",
-                        style="white",
-                    )
-                elif var == "STRIX_REASONING_EFFORT":
-                    error_text.append("• ", style="white")
-                    error_text.append("STRIX_REASONING_EFFORT", style="bold cyan")
-                    error_text.append(
-                        " - Reasoning effort level: none, minimal, low, medium, high, xhigh, "
-                        "max (default: high)\n",
-                        style="white",
-                    )
-
-        error_text.append("\nExample setup:\n", style="white")
-        error_text.append("export STRIX_LLM='openai/gpt-5.4'\n", style="dim white")
-
-        if missing_optional_vars:
-            for var in missing_optional_vars:
-                if var == "LLM_API_BASE":
-                    error_text.append(
-                        "export LLM_API_BASE='http://localhost:11434'  "
-                        "# needed for local models only\n",
-                        style="dim white",
-                    )
-                elif var == "PERPLEXITY_API_KEY":
-                    error_text.append(
-                        "export PERPLEXITY_API_KEY='your-perplexity-key-here'\n", style="dim white"
-                    )
-                elif var == "STRIX_REASONING_EFFORT":
-                    error_text.append(
-                        "export STRIX_REASONING_EFFORT='high'\n",
-                        style="dim white",
-                    )
-
-        panel = Panel(
-            error_text,
-            title="[bold white]STRIX",
-            title_align="left",
-            border_style="red",
-            padding=(1, 2),
-        )
-
-        logger.debug("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.debug("Docker CLI not found in PATH")
-        console = Console()
-        error_text = Text()
-        error_text.append("DOCKER NOT INSTALLED", style="bold red")
-        error_text.append("\n\n", style="white")
-        error_text.append("The 'docker' CLI was not found in your PATH.\n", style="white")
-        error_text.append(
-            "Please install Docker and ensure the 'docker' command is available.\n\n", style="white"
-        )
-
-        panel = Panel(
-            error_text,
-            title="[bold white]STRIX",
-            title_align="left",
-            border_style="red",
-            padding=(1, 2),
-        )
-        console.print("\n", panel, "\n")
-        sys.exit(1)
-    logger.debug("Docker CLI present")
-
-
-def pull_docker_image() -> None:
-    from docker.errors import DockerException
-
-    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)
-        return
-
-    logger.info("Pulling docker image: %s", image)
-    console.print()
-    console.print(f"[dim]Pulling image[/] {image}")
-    console.print("[dim yellow]This only happens on first run and may take a few minutes...[/]")
-    console.print()
-
-    with console.status("[bold cyan]Downloading image layers...", spinner="dots") as status:
-        try:
-            layers_info: dict[str, str] = {}
-            last_update = ""
-
-            for line in client.api.pull(image, stream=True, decode=True):
-                last_update = process_pull_line(line, layers_info, status, last_update)
-
-        except DockerException as e:
-            logger.debug("Failed to pull docker image %s", image, exc_info=True)
-            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(str(e), style="dim red")
-
-            panel = Panel(
-                error_text,
-                title="[bold white]STRIX",
-                title_align="left",
-                border_style="red",
-                padding=(1, 2),
-            )
-            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()

strix/interface/interactive.py

@@ -1,38 +0,0 @@
-"""Launch the interactive terminal interface."""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING
-
-
-if TYPE_CHECKING:
-    import argparse
-
-
-logger = logging.getLogger(__name__)
-
-
-class InteractiveSetupUnavailableError(RuntimeError):
-    """Raised when the interactive TUI cannot be launched."""
-
-
-async def run_tui(args: argparse.Namespace) -> None:
-    """Run the Bubble Tea TUI."""
-    from strix.interface.tui.runtime import (
-        GoTuiPreActivationError,
-        run_go_tui,
-    )
-
-    try:
-        await run_go_tui(args)
-    except GoTuiPreActivationError as exc:
-        raise InteractiveSetupUnavailableError(
-            f"The interactive interface could not start: {exc}"
-        ) from exc
-
-
-__all__ = [
-    "InteractiveSetupUnavailableError",
-    "run_tui",
-]

strix/interface/main.py

@@ -5,264 +5,433 @@ Strix Agent Interface
 
 import argparse
 import asyncio
-import contextlib
-import os
+import logging
+import shutil
 import sys
 from pathlib import Path
+from typing import Any
 
+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 codex, load_settings, persist_current
-from strix.core.paths import run_dir_for
-from strix.interface.cli_args import parse_arguments
-from strix.interface.environment import (
-    check_docker_installed,
-    pull_docker_image,
-    validate_environment,
-)
-from strix.interface.interactive import (
-    InteractiveSetupUnavailableError,
-    run_tui,
-)
-from strix.interface.scan_setup import (
-    ModelConnectionError,
-    preflight_model_connection,
-    prepare_run,
-    telemetry_start,
-)
-from strix.interface.update_check import (
-    is_binary_install,
-    notify_update,
-    prompt_update_if_available,
-    start_background_check,
-)
-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,
+    check_docker_connection,
+    clone_repository,
+    collect_local_sources,
+    generate_run_name,
+    image_exists,
+    infer_target_type,
+    process_pull_line,
+    resolve_diff_scope_context,
+    rewrite_localhost_targets,
+    validate_config_file,
+    validate_llm_response,
 )
-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
 
 
-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 _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
-
-
-def _subscription_error_hint(exc: BaseException) -> str | None:
-    """Return an actionable hint for a known ChatGPT-subscription error, or None."""
-    if not codex.subscription_model(load_settings().llm.model):
-        return None
-    joined = " ".join(_exception_messages(exc)).lower()
-    if "not supported when using codex with a chatgpt account" in joined:
-        return (
-            "This model isn't available on your ChatGPT subscription. "
-            "Set STRIX_LLM to a model your plan includes (e.g. chatgpt/gpt-5.4)."
+def validate_environment() -> None:  # noqa: PLR0912, PLR0915
+    console = Console()
+    missing_required_vars = []
+    missing_optional_vars = []
+
+    strix_llm = Config.get("strix_llm")
+    uses_strix_models = strix_llm and strix_llm.startswith("strix/")
+
+    if not strix_llm:
+        missing_required_vars.append("STRIX_LLM")
+
+    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 has_base_url:
+        missing_optional_vars.append("LLM_API_BASE")
+
+    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")
+        error_text.append("\n\n", style="white")
+
+        for var in missing_required_vars:
+            error_text.append(f"• {var}", style="bold yellow")
+            error_text.append(" is not set\n", style="white")
+
+        if missing_optional_vars:
+            error_text.append("\nOptional environment variables:\n", style="dim white")
+            for var in missing_optional_vars:
+                error_text.append(f"• {var}", style="dim yellow")
+                error_text.append(" is not set\n", style="dim white")
+
+        error_text.append("\nRequired environment variables:\n", style="white")
+        for var in missing_required_vars:
+            if var == "STRIX_LLM":
+                error_text.append("• ", style="white")
+                error_text.append("STRIX_LLM", style="bold cyan")
+                error_text.append(
+                    " - Model name to use with litellm (e.g., 'openai/gpt-5.4')\n",
+                    style="white",
+                )
+
+        if missing_optional_vars:
+            error_text.append("\nOptional environment variables:\n", style="white")
+            for var in missing_optional_vars:
+                if var == "LLM_API_KEY":
+                    error_text.append("• ", style="white")
+                    error_text.append("LLM_API_KEY", style="bold cyan")
+                    error_text.append(
+                        " - API key for the LLM provider "
+                        "(not needed for local models, Vertex AI, AWS, etc.)\n",
+                        style="white",
+                    )
+                elif var == "LLM_API_BASE":
+                    error_text.append("• ", style="white")
+                    error_text.append("LLM_API_BASE", style="bold cyan")
+                    error_text.append(
+                        " - Custom API base URL if using local models (e.g., Ollama, LMStudio)\n",
+                        style="white",
+                    )
+                elif var == "PERPLEXITY_API_KEY":
+                    error_text.append("• ", style="white")
+                    error_text.append("PERPLEXITY_API_KEY", style="bold cyan")
+                    error_text.append(
+                        " - API key for Perplexity AI web search (enables real-time research)\n",
+                        style="white",
+                    )
+                elif var == "STRIX_REASONING_EFFORT":
+                    error_text.append("• ", style="white")
+                    error_text.append("STRIX_REASONING_EFFORT", style="bold cyan")
+                    error_text.append(
+                        " - Reasoning effort level: none, minimal, low, medium, high, xhigh "
+                        "(default: high)\n",
+                        style="white",
+                    )
+
+        error_text.append("\nExample setup:\n", style="white")
+        error_text.append("export STRIX_LLM='openai/gpt-5.4'\n", style="dim white")
+
+        if missing_optional_vars:
+            for var in missing_optional_vars:
+                if var == "LLM_API_KEY":
+                    error_text.append(
+                        "export LLM_API_KEY='your-api-key-here'  "
+                        "# not needed for local models, Vertex AI, AWS, etc.\n",
+                        style="dim white",
+                    )
+                elif var == "LLM_API_BASE":
+                    error_text.append(
+                        "export LLM_API_BASE='http://localhost:11434'  "
+                        "# needed for local models only\n",
+                        style="dim white",
+                    )
+                elif var == "PERPLEXITY_API_KEY":
+                    error_text.append(
+                        "export PERPLEXITY_API_KEY='your-perplexity-key-here'\n", style="dim white"
+                    )
+                elif var == "STRIX_REASONING_EFFORT":
+                    error_text.append(
+                        "export STRIX_REASONING_EFFORT='high'\n",
+                        style="dim white",
+                    )
+
+        panel = Panel(
+            error_text,
+            title="[bold white]STRIX",
+            title_align="left",
+            border_style="red",
+            padding=(1, 2),
         )
-    if (
-        "error code: 401" in joined
-        or "http 401" in joined
-        or "unauthorized" in joined
-        or "invalid_grant" in joined
-    ):
-        return (
-            "Your ChatGPT sign-in has expired or was revoked. Sign in again:\n"
-            "  strix auth login chatgpt"
+
+        console.print("\n")
+        console.print(panel)
+        console.print()
+        sys.exit(1)
+
+
+def check_docker_installed() -> None:
+    if shutil.which("docker") is None:
+        console = Console()
+        error_text = Text()
+        error_text.append("DOCKER NOT INSTALLED", style="bold red")
+        error_text.append("\n\n", style="white")
+        error_text.append("The 'docker' CLI was not found in your PATH.\n", style="white")
+        error_text.append(
+            "Please install Docker and ensure the 'docker' command is available.\n\n", style="white"
         )
-    return None
 
+        panel = Panel(
+            error_text,
+            title="[bold white]STRIX",
+            title_align="left",
+            border_style="red",
+            padding=(1, 2),
+        )
+        console.print("\n", panel, "\n")
+        sys.exit(1)
 
-async def warm_up_llm(show_model_warning: bool = True) -> None:
-    from agents.model_settings import ModelSettings
-    from agents.models.interface import ModelTracing
-
-    from strix.config.models import (
-        RECOMMENDED_MODEL_NAMES,
-        StrixProvider,
-        configure_sdk_model_defaults,
-        is_known_openai_bare_model,
-        is_recommended_or_frontier_model,
-    )
-    from strix.core.inputs import make_model_settings
 
+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
-        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)
+        model_name, api_key, api_base = resolve_llm_config()
+        litellm_model, _ = resolve_strix_model(model_name)
+        litellm_model = litellm_model or model_name
 
-        if show_model_warning and raw_model and not is_recommended_or_frontier_model(raw_model):
-            warn_text = Text()
-            warn_text.append("MODEL QUALITY WARNING", 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 recommended frontier model for Strix.\nSecurity scans work best with:\n",
-                style="white",
-            )
-            for recommended_model in RECOMMENDED_MODEL_NAMES:
-                warn_text.append(f"• {recommended_model}\n", style="bold cyan")
-            warn_text.append(
-                "\nYou can continue, but weaker models may miss vulnerabilities "
-                "or produce lower-quality findings.",
-                style="white",
-            )
-            console.print(
-                Panel(
-                    warn_text,
-                    title="[bold white]STRIX",
-                    title_align="left",
-                    border_style="yellow",
-                    padding=(1, 2),
-                ),
-            )
+        test_messages = [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Reply with just 'OK'."},
+        ]
 
-        await preflight_model_connection(raw_model, settings=settings)
-        logger.info("LLM warm-up succeeded for model %s", (llm.model or "").strip())
+        llm_timeout = int(Config.get("llm_timeout") or "300")
 
-        if settings.dedupe.model:
-            from strix.report.dedupe import _dedupe_extra_args
+        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
 
-            dedupe_model = settings.dedupe.model.strip()
-            raw_model = dedupe_model
-            deduper = StrixProvider().get_model(dedupe_model)
-            deduper_extra = _dedupe_extra_args(settings.dedupe)
-            # A dedicated dedupe model may route to another provider, which must
-            # never receive the main endpoint's headers; it has its own
-            # DEDUPE_LLM_EXTRA_HEADERS.
-            deduper_settings = make_model_settings(
-                None,
-                model_name=dedupe_model,
-                request_timeout=llm.timeout,
-                prompt_cache=False,
-                extra_headers=settings.dedupe.extra_headers,
-                has_tools=False,
+        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")
+        error_text.append(f"\nError: {e}", style="dim white")
+
+        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)
+
+
+def get_version() -> str:
+    try:
+        from importlib.metadata import version
+
+        return version("strix-agent")
+    except Exception:  # noqa: BLE001
+        return "unknown"
+
+
+def parse_arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Strix Multi-Agent Cybersecurity Penetration Testing Tool",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Web application penetration test
+  strix --target https://example.com
+
+  # GitHub repository analysis
+  strix --target https://github.com/user/repo
+  strix --target git@github.com:user/repo.git
+
+  # Local code analysis
+  strix --target ./my-project
+
+  # Domain penetration test
+  strix --target example.com
+
+  # IP address penetration test
+  strix --target 192.168.1.42
+
+  # Multiple targets (e.g., white-box testing with source and deployed app)
+  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
+
+  # Custom instructions (inline)
+  strix --target example.com --instruction "Focus on authentication vulnerabilities"
+
+  # Custom instructions (from file)
+  strix --target example.com --instruction-file ./instructions.txt
+  strix --target https://app.com --instruction-file /path/to/detailed_instructions.md
+        """,
+    )
+
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"strix {get_version()}",
+    )
+
+    parser.add_argument(
+        "-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.",
+    )
+    parser.add_argument(
+        "--instruction",
+        type=str,
+        help="Custom instructions for the penetration test. This can be "
+        "specific vulnerability types to focus on (e.g., 'Focus on IDOR and XSS'), "
+        "testing approaches (e.g., 'Perform thorough authentication testing'), "
+        "test credentials (e.g., 'Use the following credentials to access the app: "
+        "admin:password123'), "
+        "or areas of interest (e.g., 'Check login API endpoint for security issues').",
+    )
+
+    parser.add_argument(
+        "--instruction-file",
+        type=str,
+        help="Path to a file containing detailed custom instructions for the penetration test. "
+        "Use this option when you have lengthy or complex instructions saved in a file "
+        "(e.g., '--instruction-file ./detailed_instructions.txt').",
+    )
+
+    parser.add_argument(
+        "-n",
+        "--non-interactive",
+        action="store_true",
+        help=(
+            "Run in non-interactive mode (no TUI, exits on completion). "
+            "Default is interactive mode with TUI."
+        ),
+    )
+
+    parser.add_argument(
+        "-m",
+        "--scan-mode",
+        type=str,
+        choices=["quick", "standard", "deep"],
+        default="deep",
+        help=(
+            "Scan mode: "
+            "'quick' for fast CI/CD checks, "
+            "'standard' for routine testing, "
+            "'deep' for thorough security reviews (default). "
+            "Default: deep."
+        ),
+    )
+
+    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",
+    )
+
+    args = parser.parse_args()
+
+    if args.instruction and args.instruction_file:
+        parser.error(
+            "Cannot specify both --instruction and --instruction-file. Use one or the other."
+        )
+
+    if args.instruction_file:
+        instruction_path = Path(args.instruction_file)
+        try:
+            with instruction_path.open(encoding="utf-8") as f:
+                args.instruction = f.read().strip()
+                if not args.instruction:
+                    parser.error(f"Instruction file '{instruction_path}' is empty")
+        except Exception as e:  # noqa: BLE001
+            parser.error(f"Failed to read instruction file '{instruction_path}': {e}")
+
+    args.targets_info = []
+    for target in args.target:
+        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}
             )
-            if deduper_extra:
-                merged = {**(deduper_settings.extra_args or {}), **deduper_extra}
-                deduper_settings = deduper_settings.resolve(ModelSettings(extra_args=merged))
-            await asyncio.wait_for(
-                deduper.get_response(
-                    system_instructions="You are a helpful assistant.",
-                    input="Reply with just 'OK'.",
-                    model_settings=deduper_settings,
-                    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 dedupe model %s", dedupe_model)
+        except ValueError:
+            parser.error(f"Invalid target '{target}'")
 
-    except ModelConnectionError:
-        logger.debug("Model route warm-up failed", exc_info=True)
-        raise
-    except Exception as exc:
-        logger.debug("LLM warm-up failed", exc_info=True)
-        raise ModelConnectionError(raw_model, exc) from exc
+    assign_workspace_subdirs(args.targets_info)
+    rewrite_localhost_targets(args.targets_info, HOST_GATEWAY_HOSTNAME)
+
+    return args
 
 
 def display_completion_message(args: argparse.Namespace, results_path: Path) -> None:
-    from strix.report.state import get_global_report_state
-
     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:
@@ -281,9 +450,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])
@@ -295,21 +464,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])
 
-    view_text = Text()
-    view_text.append("\n")
-    view_text.append("View", style="dim")
-    view_text.append("    ")
-    view_text.append(f"strix view {args.run_name}", style="#22c55e")
-    panel_parts.extend(["\n", view_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"
@@ -325,175 +479,157 @@ 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()
-    if not args.non_interactive:
-        notify_update(console)
 
 
-def _print_error_panel(title: str, message: str) -> None:
+def pull_docker_image() -> None:
     console = Console()
-    error_text = Text()
-    error_text.append(title, style="bold red")
-    error_text.append("\n\n", style="white")
-    error_text.append(message, style="white")
-    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()
+    client = check_docker_connection()
 
-
-def _print_model_connection_error(exc: BaseException, model_name: str) -> None:
-    console = Console()
-    error_text = Text()
-    sub_hint = _subscription_error_hint(exc)
-    if sub_hint is not None:
-        border_style = "yellow"
-        error_text.append("MODEL NOT AVAILABLE ON SUBSCRIPTION", style="bold yellow")
-        error_text.append("\n\n", style="white")
-        error_text.append(f"{sub_hint}\n", style="white")
-        error_text.append(f"\nDetails: {exc}", style="dim white")
-    else:
-        border_style = "red"
-        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(exc, model_name)
-        if hint is not None:
-            error_text.append(f"\n{hint}\n", style="bold yellow")
-        error_text.append(f"\nError: {exc}", style="dim white")
-
-    panel = Panel(
-        error_text,
-        title="[bold white]STRIX",
-        title_align="left",
-        border_style=border_style,
-        padding=(1, 2),
-    )
-    console.print("\n")
-    console.print(panel)
-    console.print()
-
-
-def _bootstrap_scan(args: argparse.Namespace) -> None:
-    """Warm up the model and prepare the run for a non-interactive scan.
-
-    Interactive launches only validate the environment here; the model
-    preflight and run preparation happen inside the TUI so the interface
-    paints immediately instead of waiting on a model round trip.
-    """
-    validate_environment()
-    if not args.non_interactive:
+    if image_exists(client, Config.get("strix_image")):  # type: ignore[arg-type]
         return
-    try:
-        asyncio.run(warm_up_llm(show_model_warning=True))
-    except ModelConnectionError as exc:
-        _print_model_connection_error(exc, exc.model_name)
-        sys.exit(1)
-    persist_current()
-    try:
-        prepare_run(args)
-    except ValueError as e:
-        _print_error_panel("SCAN PREPARATION FAILED", str(e))
-        sys.exit(1)
-    telemetry_start(args)
+
+    console.print()
+    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()
+
+    with console.status("[bold cyan]Downloading image layers...", spinner="dots") as status:
+        try:
+            layers_info: dict[str, str] = {}
+            last_update = ""
+
+            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:
+            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: {Config.get('strix_image')}\n", style="white")
+            error_text.append(str(e), style="dim red")
+
+            panel = Panel(
+                error_text,
+                title="[bold white]STRIX",
+                title_align="left",
+                border_style="red",
+                padding=(1, 2),
+            )
+            console.print(panel, "\n")
+            sys.exit(1)
+
+    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:  # noqa: PLR0912, PLR0915
     if sys.platform == "win32":
         asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
-    # `strix view [<run>]` is a viewer-only subcommand, dispatched before the
-    # scan argument parser (which requires a target) and before any scan setup.
-    if len(sys.argv) > 1 and sys.argv[1] == "view":
-        from strix.interface.viewer.cli import run_view
-
-        run_view(sys.argv[2:])
-        return
-
-    # `strix auth …` manages model-subscription sign-in and exits; it needs no
-    # target, Docker, or scan setup.
-    if len(sys.argv) > 1 and sys.argv[1] == "auth":
-        from strix.interface.auth_cli import run_auth
-
-        sys.exit(run_auth(sys.argv[2:]))
-
     args = parse_arguments()
 
-    start_background_check()
-    if not args.non_interactive and prompt_update_if_available(Console()):
-        if is_binary_install() and sys.platform != "win32":
-            os.execv(sys.executable, sys.argv)  # noqa: S606  # nosec B606
-        sys.exit(0)
+    if args.config:
+        apply_config_override(args.config)
 
     check_docker_installed()
     pull_docker_image()
 
-    # In setup mode the TUI collects the target, then runs prepare_run(),
-    # warm-up, and telemetry itself once the user starts the scan.
-    if not args.needs_setup:
-        _bootstrap_scan(args)
+    validate_environment()
+    asyncio.run(warm_up_llm())
 
-    from strix.report.state import get_global_report_state
+    persist_config()
+
+    args.run_name = generate_run_name(args.targets_info)
+
+    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")
+
+        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)
+
+    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
+
+    is_whitebox = bool(args.local_sources)
+
+    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:
         if args.non_interactive:
-            from strix.interface.cli import run_cli
-
             asyncio.run(run_cli(args))
         else:
             asyncio.run(run_tui(args))
-    except InteractiveSetupUnavailableError as exc:
-        exit_reason = "error"
-        _print_error_panel("INTERACTIVE SETUP UNAVAILABLE", str(exc))
-        sys.exit(1)
     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)
-            # Best-effort beacons on the way out. They reach the network, so a
-            # second Ctrl-C lands here; abandon them rather than trading a clean
-            # exit for a traceback.
-            with contextlib.suppress(KeyboardInterrupt, Exception):
-                posthog.end(report_state, exit_reason=exit_reason)
-                scarf.end(report_state, exit_reason=exit_reason)
-
-    if not args.run_name:
-        # Setup mode where the user quit before starting a scan: nothing ran.
-        return
-
-    results_path = run_dir_for(args.run_name)
+        tracer = get_global_tracer()
+        if tracer:
+            posthog.end(tracer, exit_reason=exit_reason)
 
+    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/scan_setup.py

@@ -1,266 +0,0 @@
-"""Scan bootstrap shared by the CLI entry point and the TUI setup flow.
-
-Target resolution, run preparation, model preflight, and start-of-run
-telemetry live here so ``strix.interface.main`` (the CLI) and
-``strix.interface.tui.runtime`` (interactive setup) depend on one module
-instead of each other. Everything raises ordinary exceptions; rendering
-errors and exiting the process is the caller's job.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from datetime import UTC, datetime
-from typing import TYPE_CHECKING, Any
-
-from strix.config import Settings, codex, load_settings
-from strix.core.paths import run_dir_for
-from strix.interface.utils import (
-    assign_workspace_subdirs,
-    clone_repository,
-    collect_local_sources,
-    dedupe_local_targets,
-    derive_local_base_name,
-    generate_run_name,
-    infer_target_type,
-    is_whitebox_scan,
-    read_target_list_file,
-    resolve_diff_scope_context,
-    rewrite_localhost_targets,
-    stage_api_specs,
-    write_fetched_collection,
-)
-from strix.telemetry import posthog, scarf
-from strix.utils.api_spec import (
-    SpecParseError,
-    fetch_postman_collection,
-    fetch_postman_environment,
-    load_spec,
-    spec_base_urls,
-    spec_title,
-)
-
-
-if TYPE_CHECKING:
-    import argparse
-
-logger = logging.getLogger(__name__)
-
-HOST_GATEWAY_HOSTNAME = "host.docker.internal"
-
-
-class ModelConnectionError(RuntimeError):
-    """An ordinary model preflight failure, annotated with its model route."""
-
-    def __init__(self, model_name: str, cause: BaseException) -> None:
-        super().__init__(str(cause))
-        self.model_name = model_name
-
-
-async def preflight_model_connection(
-    model_name: str,
-    *,
-    settings: Settings | None = None,
-) -> None:
-    """Verify the configured model route before starting a scan."""
-    from agents.models.interface import ModelTracing
-
-    from strix.config.models import StrixProvider, configure_sdk_model_defaults
-    from strix.core.inputs import make_model_settings
-
-    resolved_settings = load_settings() if settings is None else settings
-    configure_sdk_model_defaults(resolved_settings)
-    model = StrixProvider().get_model(model_name)
-    request_settings = make_model_settings(
-        None,
-        model_name=model_name,
-        request_timeout=resolved_settings.llm.timeout,
-        prompt_cache=False,
-        extra_headers=resolved_settings.llm.extra_headers,
-        has_tools=False,
-    )
-    await asyncio.wait_for(
-        model.get_response(
-            system_instructions="You are a helpful assistant.",
-            input="Reply with just 'OK'.",
-            model_settings=request_settings,
-            tools=[],
-            output_schema=None,
-            handoffs=[],
-            tracing=ModelTracing.DISABLED,
-            previous_response_id=None,
-            conversation_id=None,
-            prompt=None,
-        ),
-        timeout=resolved_settings.llm.timeout,
-    )
-
-
-def build_targets_info(args: argparse.Namespace) -> None:
-    """Populate ``args.targets_info`` from target/target-list inputs.
-
-    Raises :class:`ValueError` with a user-facing message on any bad input so
-    callers can surface it via ``parser.error`` (CLI) or a console panel (home
-    page).
-    """
-    args.targets_info = []
-    targets = list(args.target or [])
-    for target_list_path in args.target_list or []:
-        targets.extend(read_target_list_file(target_list_path))
-
-    for target in targets:
-        try:
-            target_type, target_dict = infer_target_type(target)
-        except ValueError as e:
-            raise ValueError(f"Invalid target '{target}': {e}") from None
-
-        if target_type == "local_code":
-            display_target = target_dict.get("target_path", target)
-        else:
-            display_target = target
-
-        if target_type == "api_spec":
-            _resolve_api_spec(target, target_dict)
-
-        args.targets_info.append(
-            {"type": target_type, "details": target_dict, "original": display_target}
-        )
-
-    args.targets_info = dedupe_local_targets(args.targets_info)
-
-    assign_workspace_subdirs(args.targets_info)
-    rewrite_localhost_targets(args.targets_info, HOST_GATEWAY_HOSTNAME)
-
-
-def _resolve_api_spec(target: str, details: dict[str, Any]) -> None:
-    """Read the spec up front so bad input fails before the run starts.
-
-    Records the declared base URLs (the only thing scope authorization can take
-    from a spec) and, for a ``postman://`` target, downloads the collection to a
-    local file so the sandbox never needs the Postman API key.
-    """
-    try:
-        if details.get("source") == "postman_api":
-            collection_uid = str(details["collection_uid"])
-            api_key = load_settings().integrations.postman_api_key or ""
-            raw = fetch_postman_collection(collection_uid, api_key)
-            environment_uid = str(details.get("environment_uid") or "")
-            extra_variables = (
-                fetch_postman_environment(environment_uid, api_key) if environment_uid else None
-            )
-            details["target_spec"] = write_fetched_collection(raw, collection_uid)
-        else:
-            raw = load_spec(str(details["target_spec"]))
-            extra_variables = None
-        base_urls = spec_base_urls(raw, extra_variables=extra_variables)
-    except SpecParseError as exc:
-        raise ValueError(f"Invalid API spec '{target}': {exc}") from None
-
-    details["spec_title"] = spec_title(raw)
-    details["base_urls"] = base_urls
-
-
-def prepare_run(args: argparse.Namespace) -> None:
-    """Resolve the run name, clone repos, compute diff-scope, and persist state.
-
-    Shared by the CLI startup path and the interactive TUI setup phase (once the
-    user has supplied a target via ``/target``). Mutates *args* in place and
-    raises :class:`ValueError` on any preparation failure.
-    """
-    args.run_name = args.resume or generate_run_name(args.targets_info)
-
-    if args.resume:
-        return
-
-    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)
-    args.local_sources.extend(stage_api_specs(args.targets_info, args.run_name))
-    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,
-    )
-    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
-
-    attach_workspace_mount(args)
-    _persist_run_record(args)
-
-
-def attach_workspace_mount(args: argparse.Namespace) -> None:
-    """Expose ``args.workspace_mount`` to the sandbox without making it a target.
-
-    A workspace mount is a directory the agent works in, not something to test:
-    it stays out of ``targets_info``, so it carries no authorized scope, and it
-    is attached after diff-scope resolution so it contributes no diff context.
-    The instruction is the only source of truth for what to do with it.
-    """
-    mount = getattr(args, "workspace_mount", None)
-    if not mount:
-        return
-    args.workspace_subdir = derive_local_base_name(mount)
-    local_sources = list(getattr(args, "local_sources", None) or [])
-    local_sources.append(
-        {
-            "source_path": mount,
-            "workspace_subdir": args.workspace_subdir,
-            "protect_metadata": True,
-        }
-    )
-    args.local_sources = local_sources
-
-
-def telemetry_start(args: argparse.Namespace) -> None:
-    model = load_settings().llm.model
-    kwargs = {
-        "model": model,
-        "auth_mode": codex.auth_mode(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(**kwargs)
-    scarf.start(**kwargs)
-
-
-def _persist_run_record(args: argparse.Namespace) -> None:
-    from strix.report.writer import write_run_record
-
-    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,
-        "auth_mode": codex.auth_mode(load_settings().llm.model),
-        "targets_info": args.targets_info,
-        "scan_mode": args.scan_mode,
-        "instruction": args.instruction,
-        # Kept apart from instruction, which carries the diff-scope preamble: the
-        # transcript replays this as the user's opening message.
-        "user_instruction": getattr(args, "user_instruction", None),
-        "non_interactive": args.non_interactive,
-        "local_sources": getattr(args, "local_sources", []),
-        # Persisted so --resume can remount the workspace: it is not a target,
-        # so it cannot be rebuilt from targets_info.
-        "workspace_mount": getattr(args, "workspace_mount", None),
-        "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)

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

@@ -0,0 +1,190 @@
+from functools import cache
+from typing import Any, ClassVar
+
+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
+
+from .base_renderer import BaseToolRenderer
+from .registry import register_tool_renderer
+
+
+_HEADER_STYLES = [
+    ("###### ", 7, "bold #4ade80"),
+    ("##### ", 6, "bold #22c55e"),
+    ("#### ", 5, "bold #16a34a"),
+    ("### ", 4, "bold #15803d"),
+    ("## ", 3, "bold #22c55e"),
+    ("# ", 2, "bold #4ade80"),
+]
+
+
+@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_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, language: str | None = None) -> Text:
+    text = Text()
+
+    try:
+        lexer = get_lexer_by_name(language) if language else guess_lexer(code)
+    except ClassNotFound:
+        text.append(code, style="#d4d4d4")
+        return 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 _try_parse_header(line: str) -> tuple[str, str] | None:
+    for prefix, strip_len, style in _HEADER_STYLES:
+        if line.startswith(prefix):
+            return (line[strip_len:], style)
+    return None
+
+
+def _apply_markdown_styles(text: str) -> Text:  # noqa: PLR0912
+    result = Text()
+    lines = text.split("\n")
+
+    in_code_block = False
+    code_block_lang: str | None = None
+    code_block_lines: list[str] = []
+
+    for i, line in enumerate(lines):
+        if i > 0 and not in_code_block:
+            result.append("\n")
+
+        if line.startswith("```"):
+            if not in_code_block:
+                in_code_block = True
+                code_block_lang = line[3:].strip() or None
+                code_block_lines = []
+                if i > 0:
+                    result.append("\n")
+            else:
+                in_code_block = False
+                code_content = "\n".join(code_block_lines)
+                if code_content:
+                    result.append_text(_highlight_code(code_content, code_block_lang))
+                code_block_lines = []
+                code_block_lang = None
+            continue
+
+        if in_code_block:
+            code_block_lines.append(line)
+            continue
+
+        header = _try_parse_header(line)
+        if header:
+            result.append(header[0], style=header[1])
+        elif line.startswith("> "):
+            result.append("┃ ", style="#22c55e")
+            result.append_text(_process_inline_formatting(line[2:]))
+        elif line.startswith(("- ", "* ")):
+            result.append("• ", style="#22c55e")
+            result.append_text(_process_inline_formatting(line[2:]))
+        elif len(line) > 2 and line[0].isdigit() and line[1:3] in (". ", ") "):
+            result.append(line[0] + ". ", style="#22c55e")
+            result.append_text(_process_inline_formatting(line[2:]))
+        elif line.strip() in ("---", "***", "___"):
+            result.append("─" * 40, style="#22c55e")
+        else:
+            result.append_text(_process_inline_formatting(line))
+
+    if in_code_block and code_block_lines:
+        code_content = "\n".join(code_block_lines)
+        result.append_text(_highlight_code(code_content, code_block_lang))
+
+    return result
+
+
+def _process_inline_formatting(line: str) -> Text:
+    result = Text()
+    i = 0
+    n = len(line)
+
+    while i < n:
+        if i + 1 < n and line[i : i + 2] in ("**", "__"):
+            marker = line[i : i + 2]
+            end = line.find(marker, i + 2)
+            if end != -1:
+                result.append(line[i + 2 : end], style="bold #4ade80")
+                i = end + 2
+                continue
+
+        if i + 1 < n and line[i : i + 2] == "~~":
+            end = line.find("~~", i + 2)
+            if end != -1:
+                result.append(line[i + 2 : end], style="strike #525252")
+                i = end + 2
+                continue
+
+        if line[i] == "`":
+            end = line.find("`", i + 1)
+            if end != -1:
+                result.append(line[i + 1 : end], style="bold #22c55e on #0a0a0a")
+                i = end + 1
+                continue
+
+        if line[i] in ("*", "_"):
+            marker = line[i]
+            if i + 1 < n and line[i + 1] != marker:
+                end = line.find(marker, i + 1)
+                if end != -1 and (end + 1 >= n or line[end + 1] != marker):
+                    result.append(line[i + 1 : end], style="italic #86efac")
+                    i = end + 1
+                    continue
+
+        result.append(line[i])
+        i += 1
+
+    return result
+
+
+@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()
+
+        from strix.llm.utils import clean_content
+
+        cleaned = clean_content(content)
+        if not cleaned:
+            return Text()
+
+        return _apply_markdown_styles(cleaned)

strix/interface/tool_components/agents_graph_renderer.py

@@ -0,0 +1,140 @@
+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 ViewAgentGraphRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "view_agent_graph"
+    css_classes: ClassVar[list[str]] = ["tool-call", "agents-graph-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        status = tool_data.get("status", "unknown")
+
+        text = Text()
+        text.append("◇ ", style="#a78bfa")
+        text.append("viewing agents graph", style="dim")
+
+        css_classes = cls.get_css_classes(status)
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class CreateAgentRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "create_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", {})
+        status = tool_data.get("status", "unknown")
+
+        task = args.get("task", "")
+        name = args.get("name", "Agent")
+
+        text = Text()
+        text.append("◈ ", style="#a78bfa")
+        text.append("spawning ", 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)
+
+
+@register_tool_renderer
+class SendMessageToAgentRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "send_message_to_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", {})
+        status = tool_data.get("status", "unknown")
+
+        message = args.get("message", "")
+        agent_id = args.get("agent_id", "")
+
+        text = Text()
+        text.append("→ ", style="#60a5fa")
+        if agent_id:
+            text.append(f"to {agent_id}", style="dim")
+        else:
+            text.append("sending message", style="dim")
+
+        if message:
+            text.append("\n  ")
+            text.append(message, style="dim")
+
+        css_classes = cls.get_css_classes(status)
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class AgentFinishRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "agent_finish"
+    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_summary = args.get("result_summary", "")
+        findings = args.get("findings", [])
+        success = args.get("success", True)
+
+        text = Text()
+
+        if success:
+            text.append("◆ ", style="#22c55e")
+            text.append("Agent completed", style="bold #22c55e")
+        else:
+            text.append("◆ ", style="#ef4444")
+            text.append("Agent failed", style="bold #ef4444")
+
+        if result_summary:
+            text.append("\n  ")
+            text.append(result_summary, style="bold")
+
+            if findings and isinstance(findings, list):
+                for finding in findings:
+                    text.append("\n  • ")
+                    text.append(str(finding), style="dim")
+        else:
+            text.append("\n  ")
+            text.append("Completing task...", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class WaitForMessageRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "wait_for_message"
+    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", {})
+        status = tool_data.get("status", "unknown")
+
+        reason = args.get("reason", "")
+
+        text = Text()
+        text.append("○ ", style="#6b7280")
+        text.append("waiting", style="dim")
+
+        if reason:
+            text.append("\n  ")
+            text.append(reason, style="dim")
+
+        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/finish_renderer.py

@@ -0,0 +1,65 @@
+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
+
+
+FIELD_STYLE = "bold #4ade80"
+
+
+@register_tool_renderer
+class FinishScanRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "finish_scan"
+    css_classes: ClassVar[list[str]] = ["tool-call", "finish-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        executive_summary = args.get("executive_summary", "")
+        methodology = args.get("methodology", "")
+        technical_analysis = args.get("technical_analysis", "")
+        recommendations = args.get("recommendations", "")
+
+        text = Text()
+        text.append("◆ ", style="#22c55e")
+        text.append("Penetration test completed", style="bold #22c55e")
+
+        if executive_summary:
+            text.append("\n\n")
+            text.append("Executive Summary", style=FIELD_STYLE)
+            text.append("\n")
+            text.append(executive_summary)
+
+        if methodology:
+            text.append("\n\n")
+            text.append("Methodology", style=FIELD_STYLE)
+            text.append("\n")
+            text.append(methodology)
+
+        if technical_analysis:
+            text.append("\n\n")
+            text.append("Technical Analysis", style=FIELD_STYLE)
+            text.append("\n")
+            text.append(technical_analysis)
+
+        if recommendations:
+            text.append("\n\n")
+            text.append("Recommendations", style=FIELD_STYLE)
+            text.append("\n")
+            text.append(recommendations)
+
+        if not (executive_summary or methodology or technical_analysis or recommendations):
+            text.append("\n  ")
+            text.append("Generating final report...", style="dim")
+
+        padded = Text()
+        padded.append("\n\n")
+        padded.append_text(text)
+        padded.append("\n\n")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(padded, classes=css_classes)

strix/interface/tool_components/load_skill_renderer.py

@@ -0,0 +1,33 @@
+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 LoadSkillRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "load_skill"
+    css_classes: ClassVar[list[str]] = ["tool-call", "load-skill-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        status = tool_data.get("status", "completed")
+
+        requested = args.get("skills", "")
+
+        text = Text()
+        text.append("◇ ", style="#10b981")
+        text.append("loading skill", style="dim")
+
+        if requested:
+            text.append(" ")
+            text.append(requested, style="#10b981")
+        elif not tool_data.get("result"):
+            text.append("\n  ")
+            text.append("Loading...", style="dim")
+
+        return Static(text, classes=cls.get_css_classes(status))

strix/interface/tool_components/notes_renderer.py

@@ -0,0 +1,167 @@
+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 CreateNoteRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "create_note"
+    css_classes: ClassVar[list[str]] = ["tool-call", "notes-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        title = args.get("title", "")
+        content = args.get("content", "")
+        category = args.get("category", "general")
+
+        text = Text()
+        text.append("◇ ", style="#fbbf24")
+        text.append("note", style="dim")
+        text.append(" ")
+        text.append(f"({category})", style="dim")
+
+        if title:
+            text.append("\n  ")
+            text.append(title.strip())
+
+        if content:
+            text.append("\n  ")
+            text.append(content.strip(), style="dim")
+
+        if not title and not content:
+            text.append("\n  ")
+            text.append("Capturing...", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class DeleteNoteRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "delete_note"
+    css_classes: ClassVar[list[str]] = ["tool-call", "notes-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:  # noqa: ARG003
+        text = Text()
+        text.append("◇ ", style="#fbbf24")
+        text.append("note removed", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class UpdateNoteRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "update_note"
+    css_classes: ClassVar[list[str]] = ["tool-call", "notes-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+
+        title = args.get("title")
+        content = args.get("content")
+
+        text = Text()
+        text.append("◇ ", style="#fbbf24")
+        text.append("note updated", style="dim")
+
+        if title:
+            text.append("\n  ")
+            text.append(title)
+
+        if content:
+            text.append("\n  ")
+            text.append(content.strip(), style="dim")
+
+        if not title and not content:
+            text.append("\n  ")
+            text.append("Updating...", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class ListNotesRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "list_notes"
+    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("notes", style="dim")
+
+        if isinstance(result, str) and result.strip():
+            text.append("\n  ")
+            text.append(result.strip(), style="dim")
+        elif result and isinstance(result, dict) and result.get("success"):
+            count = result.get("total_count", 0)
+            notes = result.get("notes", []) or []
+
+            if count == 0:
+                text.append("\n  ")
+                text.append("No notes", style="dim")
+            else:
+                for note in notes:
+                    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)
+                    text.append(f" ({category})", style="dim")
+
+                    if note_content:
+                        text.append("\n    ")
+                        text.append(note_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)
+
+
+@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

@@ -0,0 +1,610 @@
+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
+
+
+PROXY_ICON = "<~>"
+MAX_REQUESTS_DISPLAY = 20
+MAX_LINE_LENGTH = 200
+
+
+def _truncate(text: str, max_len: int = 80) -> str:
+    return text[: max_len - 3] + "..." if len(text) > max_len else text
+
+
+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)
+
+
+def _status_style(code: int | None) -> str:
+    if code is None:
+        return "dim"
+    if 200 <= code < 300:
+        return "#22c55e"  # green
+    if 300 <= code < 400:
+        return "#eab308"  # yellow
+    if 400 <= code < 500:
+        return "#f97316"  # orange
+    if code >= 500:
+        return "#ef4444"  # red
+    return "dim"
+
+
+@register_tool_renderer
+class ListRequestsRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "list_requests"
+    css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]
+
+    @classmethod
+    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")
+
+        httpql_filter = args.get("httpql_filter")
+        sort_by = args.get("sort_by")
+        sort_order = args.get("sort_order")
+        scope_id = args.get("scope_id")
+
+        text = Text()
+        text.append(PROXY_ICON, style="dim")
+        text.append(" listing requests", style="#06b6d4")
+
+        if httpql_filter:
+            text.append(f"  where {_truncate(httpql_filter, 150)}", style="dim italic")
+
+        meta_parts = []
+        if sort_by and sort_by != "timestamp":
+            meta_parts.append(f"by:{sort_by}")
+        if sort_order and sort_order != "desc":
+            meta_parts.append(sort_order)
+        if scope_id and isinstance(scope_id, str):
+            meta_parts.append(f"scope:{scope_id[:8]}")
+        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)
+                requests = result.get("requests", [])
+
+                text.append(f"  [{total} found]", style="dim")
+
+                if requests and isinstance(requests, list):
+                    text.append("\n")
+                    for i, req in enumerate(requests[:MAX_REQUESTS_DISPLAY]):
+                        if not isinstance(req, dict):
+                            continue
+                        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")
+                        text.append(f" {_truncate(host + path, 180)}", style="dim")
+                        if code:
+                            text.append(f" {code}", style=_status_style(code))
+
+                        if i < min(len(requests), MAX_REQUESTS_DISPLAY) - 1:
+                            text.append("\n")
+
+                    if len(requests) > MAX_REQUESTS_DISPLAY:
+                        text.append("\n")
+                        text.append(
+                            f"  ... +{len(requests) - MAX_REQUESTS_DISPLAY} more",
+                            style="dim italic",
+                        )
+
+        css_classes = cls.get_css_classes(status)
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class ViewRequestRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "view_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")
+
+        request_id = args.get("request_id", "")
+        part = args.get("part", "request")
+        search_pattern = args.get("search_pattern")
+
+        text = Text()
+        text.append(PROXY_ICON, style="dim")
+
+        action = "searching" if search_pattern else "viewing"
+        text.append(f" {action} {part}", style="#06b6d4")
+
+        if request_id:
+            text.append(f" #{request_id}", style="dim")
+
+        if search_pattern:
+            text.append(f"  /{_truncate(search_pattern, 100)}/", style="dim italic")
+
+        if status == "completed" and isinstance(result, dict):
+            if "error" in result:
+                text.append(f"  error: {_sanitize(str(result['error']), 150)}", style="#ef4444")
+            elif "matches" in result:
+                matches = result.get("matches", [])
+                total = result.get("total_matches", len(matches))
+                text.append(f"  [{total} matches]", style="dim")
+
+                if matches and isinstance(matches, list):
+                    text.append("\n")
+                    for i, m in enumerate(matches[:5]):
+                        if not isinstance(m, dict):
+                            continue
+                        before = m.get("before", "") or ""
+                        match_text = m.get("match", "") or ""
+                        after = m.get("after", "") or ""
+
+                        before = before.replace("\n", " ").replace("\r", "")[-100:]
+                        after = after.replace("\n", " ").replace("\r", "")[:100]
+
+                        text.append("  ")
+
+                        if before:
+                            text.append(f"...{before}", style="dim")
+                        text.append(match_text, style="#22c55e bold")
+                        if after:
+                            text.append(f"{after}...", style="dim")
+
+                        if i < min(len(matches), 5) - 1:
+                            text.append("\n")
+
+                    if len(matches) > 5:
+                        text.append("\n")
+                        text.append(f"  ... +{len(matches) - 5} more matches", style="dim italic")
+
+            elif "content" in result:
+                showing = result.get("showing_lines", "")
+                has_more = result.get("has_more", False)
+                content = result.get("content", "")
+
+                text.append(f"  [{showing}]", style="dim")
+
+                if content and isinstance(content, str):
+                    lines = content.split("\n")[:15]
+                    text.append("\n")
+                    for i, line in enumerate(lines):
+                        text.append("  ")
+                        text.append(_truncate(line, MAX_LINE_LENGTH), style="dim")
+                        if i < len(lines) - 1:
+                            text.append("\n")
+
+                    if has_more or len(lines) > 15:
+                        text.append("\n")
+                        text.append("  ... more content available", style="dim italic")
+
+        css_classes = cls.get_css_classes(status)
+        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"
+    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")
+
+        request_id = args.get("request_id", "")
+        modifications = args.get("modifications")
+
+        text = Text()
+        text.append(PROXY_ICON, style="dim")
+        text.append(" repeating request", style="#06b6d4")
+
+        if request_id:
+            text.append(f" #{request_id}", style="dim")
+
+        if modifications and isinstance(modifications, dict):
+            text.append("\n  modifications:", style="dim italic")
+
+            if "url" in modifications:
+                text.append("\n")
+                text.append("  >> ", style="#3b82f6")
+                text.append(f"url: {_truncate(str(modifications['url']), 180)}", style="dim")
+
+            if "headers" in modifications and isinstance(modifications["headers"], dict):
+                for k, v in list(modifications["headers"].items())[:5]:
+                    text.append("\n")
+                    text.append("  >> ", style="#3b82f6")
+                    text.append(f"{k}: {_sanitize(str(v), 150)}", style="dim")
+
+            if "cookies" in modifications and isinstance(modifications["cookies"], dict):
+                for k, v in list(modifications["cookies"].items())[:5]:
+                    text.append("\n")
+                    text.append("  >> ", style="#3b82f6")
+                    text.append(f"cookie {k}={_sanitize(str(v), 100)}", style="dim")
+
+            if "params" in modifications and isinstance(modifications["params"], dict):
+                for k, v in list(modifications["params"].items())[:5]:
+                    text.append("\n")
+                    text.append("  >> ", style="#3b82f6")
+                    text.append(f"param {k}={_sanitize(str(v), 100)}", style="dim")
+
+            if "body" in modifications and isinstance(modifications["body"], str):
+                text.append("\n")
+                text.append("  >> ", style="#3b82f6")
+                body_lines = modifications["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(modifications["body"].split("\n")) > 4:
+                    text.append(" ...", style="dim italic")
+
+        elif modifications and isinstance(modifications, str):
+            text.append(f"\n  {_truncate(modifications, 200)}", 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:
+                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))
+                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:
+                        text.append("\n")
+                        text.append("  << ", style="#22c55e")
+                        text.append(_truncate(line, MAX_LINE_LENGTH - 5), style="dim")
+
+                    if len(body.split("\n")) > 5:
+                        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 ScopeRulesRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "scope_rules"
+    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")
+
+        action = args.get("action", "")
+        scope_name = args.get("scope_name", "")
+        scope_id = args.get("scope_id", "")
+        allowlist = args.get("allowlist")
+        denylist = args.get("denylist")
+
+        text = Text()
+        text.append(PROXY_ICON, style="dim")
+
+        action_map = {
+            "get": "getting",
+            "list": "listing",
+            "create": "creating",
+            "update": "updating",
+            "delete": "deleting",
+        }
+        action_text = action_map.get(action, action + "ing" if action else "managing")
+        text.append(f" {action_text} proxy scope", style="#06b6d4")
+
+        if scope_name:
+            text.append(f" '{_truncate(scope_name, 50)}'", style="dim italic")
+        if scope_id and isinstance(scope_id, str):
+            text.append(f" #{scope_id[:8]}", style="dim")
+
+        if allowlist and isinstance(allowlist, list):
+            allow_str = ", ".join(_truncate(str(a), 40) for a in allowlist[:4])
+            text.append(f"\n  allow: {allow_str}", style="dim")
+            if len(allowlist) > 4:
+                text.append(f" +{len(allowlist) - 4}", style="dim italic")
+        if denylist and isinstance(denylist, list):
+            deny_str = ", ".join(_truncate(str(d), 40) for d in denylist[:4])
+            text.append(f"\n  deny: {deny_str}", style="dim")
+            if len(denylist) > 4:
+                text.append(f" +{len(denylist) - 4}", style="dim italic")
+
+        if status == "completed" and isinstance(result, dict):
+            if "error" in result:
+                text.append(f"  error: {_sanitize(str(result['error']), 150)}", style="#ef4444")
+            elif "scopes" in result:
+                scopes = result.get("scopes", [])
+                text.append(f"  [{len(scopes)} scopes]", style="dim")
+
+                if scopes and isinstance(scopes, list):
+                    text.append("\n")
+                    for i, scope in enumerate(scopes[:5]):
+                        if not isinstance(scope, dict):
+                            continue
+                        name = scope.get("name", "?")
+                        allow = scope.get("allowlist") or []
+                        text.append("  ")
+                        text.append(_truncate(str(name), 40), style="#22c55e")
+                        if allow and isinstance(allow, list):
+                            allow_str = ", ".join(_truncate(str(a), 30) for a in allow[:3])
+                            text.append(f"  {allow_str}", style="dim")
+                            if len(allow) > 3:
+                                text.append(f" +{len(allow) - 3}", style="dim italic")
+                        if i < min(len(scopes), 5) - 1:
+                            text.append("\n")
+
+            elif "scope" in result:
+                scope = result.get("scope") or {}
+                if isinstance(scope, dict):
+                    allow = scope.get("allowlist") or []
+                    deny = scope.get("denylist") or []
+
+                    if allow and isinstance(allow, list):
+                        allow_str = ", ".join(_truncate(str(a), 40) for a in allow[:5])
+                        text.append(f"\n  allow: {allow_str}", style="dim")
+                    if deny and isinstance(deny, list):
+                        deny_str = ", ".join(_truncate(str(d), 40) for d in deny[:5])
+                        text.append(f"\n  deny: {deny_str}", style="dim")
+
+            elif "message" in result:
+                text.append(f"  {result['message']}", style="#22c55e")
+
+        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

@@ -0,0 +1,79 @@
+from typing import Any, ClassVar
+
+from rich.text import Text
+from textual.widgets import Static
+
+from .base_renderer import BaseToolRenderer
+
+
+class ToolTUIRegistry:
+    _renderers: ClassVar[dict[str, type[BaseToolRenderer]]] = {}
+
+    @classmethod
+    def register(cls, renderer_class: type[BaseToolRenderer]) -> None:
+        if not renderer_class.tool_name:
+            raise ValueError(f"Renderer {renderer_class.__name__} must define tool_name")
+
+        cls._renderers[renderer_class.tool_name] = renderer_class
+
+    @classmethod
+    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)
+    return renderer_class
+
+
+def get_tool_renderer(tool_name: str) -> type[BaseToolRenderer] | None:
+    return ToolTUIRegistry.get_renderer(tool_name)
+
+
+def render_tool_widget(tool_data: dict[str, Any]) -> Static:
+    tool_name = tool_data.get("tool_name", "")
+    renderer = get_tool_renderer(tool_name)
+
+    if renderer:
+        return renderer.render(tool_data)
+    return _render_default_tool_widget(tool_data)
+
+
+def _render_default_tool_widget(tool_data: dict[str, Any]) -> Static:
+    tool_name = tool_data.get("tool_name", "Unknown Tool")
+    args = tool_data.get("args", {})
+    status = tool_data.get("status", "unknown")
+    result = tool_data.get("result")
+
+    text = Text()
+
+    text.append("→ Using tool ", style="dim")
+    text.append(tool_name, style="bold blue")
+    text.append("\n")
+
+    for k, v in list(args.items()):
+        str_v = str(v)
+        text.append("  ")
+        text.append(k, style="dim")
+        text.append(": ")
+        text.append(str_v)
+        text.append("\n")
+
+    if status in ["completed", "failed", "error"] and result is not None:
+        result_str = str(result)
+        text.append("Result: ", style="bold")
+        text.append(result_str)
+    else:
+        icon, color = BaseToolRenderer.status_icon(status)
+        text.append(icon, style=color)
+
+    css_classes = BaseToolRenderer.get_css_classes(status)
+    return Static(text, classes=css_classes)

strix/interface/tool_components/reporting_renderer.py

@@ -0,0 +1,255 @@
+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 strix.tools.reporting.reporting_actions import (
+    parse_code_locations_xml,
+    parse_cvss_xml,
+)
+
+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"]}
+
+
+FIELD_STYLE = "bold #4ade80"
+DIM_STYLE = "dim"
+FILE_STYLE = "bold #60a5fa"
+LINE_STYLE = "#facc15"
+LABEL_STYLE = "italic #a1a1aa"
+CODE_STYLE = "#e2e8f0"
+BEFORE_STYLE = "#ef4444"
+AFTER_STYLE = "#22c55e"
+
+
+@register_tool_renderer
+class CreateVulnerabilityReportRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "create_vulnerability_report"
+    css_classes: ClassVar[list[str]] = ["tool-call", "reporting-tool"]
+
+    SEVERITY_COLORS: ClassVar[dict[str, str]] = {
+        "critical": "#dc2626",
+        "high": "#ea580c",
+        "medium": "#d97706",
+        "low": "#65a30d",
+        "info": "#0284c7",
+    }
+
+    @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_python(cls, code: str) -> Text:
+        lexer = PythonLexer()
+        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 _get_cvss_color(cls, cvss_score: float) -> str:
+        if cvss_score >= 9.0:
+            return "#dc2626"
+        if cvss_score >= 7.0:
+            return "#ea580c"
+        if cvss_score >= 4.0:
+            return "#d97706"
+        if cvss_score >= 0.1:
+            return "#65a30d"
+        return "#6b7280"
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:  # noqa: PLR0912, PLR0915
+        args = tool_data.get("args", {})
+        result = tool_data.get("result", {})
+
+        title = args.get("title", "")
+        description = args.get("description", "")
+        impact = args.get("impact", "")
+        target = args.get("target", "")
+        technical_analysis = args.get("technical_analysis", "")
+        poc_description = args.get("poc_description", "")
+        poc_script_code = args.get("poc_script_code", "")
+        remediation_steps = args.get("remediation_steps", "")
+
+        cvss_breakdown_xml = args.get("cvss_breakdown", "")
+        code_locations_xml = args.get("code_locations", "")
+
+        endpoint = args.get("endpoint", "")
+        method = args.get("method", "")
+        cve = args.get("cve", "")
+        cwe = args.get("cwe", "")
+
+        severity = ""
+        cvss_score = None
+        if isinstance(result, dict):
+            severity = result.get("severity", "")
+            cvss_score = result.get("cvss_score")
+
+        text = Text()
+        text.append("🐞 ")
+        text.append("Vulnerability Report", style="bold #ea580c")
+
+        if title:
+            text.append("\n\n")
+            text.append("Title: ", style=FIELD_STYLE)
+            text.append(title)
+
+        if severity:
+            text.append("\n\n")
+            text.append("Severity: ", style=FIELD_STYLE)
+            severity_color = cls.SEVERITY_COLORS.get(severity.lower(), "#6b7280")
+            text.append(severity.upper(), style=f"bold {severity_color}")
+
+        if cvss_score is not None:
+            text.append("\n\n")
+            text.append("CVSS Score: ", style=FIELD_STYLE)
+            cvss_color = cls._get_cvss_color(cvss_score)
+            text.append(str(cvss_score), style=f"bold {cvss_color}")
+
+        if target:
+            text.append("\n\n")
+            text.append("Target: ", style=FIELD_STYLE)
+            text.append(target)
+
+        if endpoint:
+            text.append("\n\n")
+            text.append("Endpoint: ", style=FIELD_STYLE)
+            text.append(endpoint)
+
+        if method:
+            text.append("\n\n")
+            text.append("Method: ", style=FIELD_STYLE)
+            text.append(method)
+
+        if cve:
+            text.append("\n\n")
+            text.append("CVE: ", style=FIELD_STYLE)
+            text.append(cve)
+
+        if cwe:
+            text.append("\n\n")
+            text.append("CWE: ", style=FIELD_STYLE)
+            text.append(cwe)
+
+        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 [
+                ("attack_vector", "AV"),
+                ("attack_complexity", "AC"),
+                ("privileges_required", "PR"),
+                ("user_interaction", "UI"),
+                ("scope", "S"),
+                ("confidentiality", "C"),
+                ("integrity", "I"),
+                ("availability", "A"),
+            ]:
+                val = parsed_cvss.get(key)
+                if val:
+                    cvss_parts.append(f"{prefix}:{val}")
+            text.append("CVSS Vector: ", style=FIELD_STYLE)
+            text.append("/".join(cvss_parts), style=DIM_STYLE)
+
+        if description:
+            text.append("\n\n")
+            text.append("Description", style=FIELD_STYLE)
+            text.append("\n")
+            text.append(description)
+
+        if impact:
+            text.append("\n\n")
+            text.append("Impact", style=FIELD_STYLE)
+            text.append("\n")
+            text.append(impact)
+
+        if technical_analysis:
+            text.append("\n\n")
+            text.append("Technical Analysis", style=FIELD_STYLE)
+            text.append("\n")
+            text.append(technical_analysis)
+
+        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(parsed_locations):
+                text.append("\n\n")
+                text.append(f"  Location {i + 1}: ", style=DIM_STYLE)
+                text.append(loc.get("file", "unknown"), style=FILE_STYLE)
+                start = loc.get("start_line")
+                end = loc.get("end_line")
+                if start is not None:
+                    if end and end != start:
+                        text.append(f":{start}-{end}", style=LINE_STYLE)
+                    else:
+                        text.append(f":{start}", style=LINE_STYLE)
+                if loc.get("label"):
+                    text.append(f"\n  {loc['label']}", style=LABEL_STYLE)
+                if loc.get("snippet"):
+                    text.append("\n  ")
+                    text.append(loc["snippet"], style=CODE_STYLE)
+                if loc.get("fix_before") or loc.get("fix_after"):
+                    text.append("\n  ")
+                    text.append("Fix:", style=DIM_STYLE)
+                    if loc.get("fix_before"):
+                        text.append("\n  ")
+                        text.append("- ", style=BEFORE_STYLE)
+                        text.append(loc["fix_before"], style=BEFORE_STYLE)
+                    if loc.get("fix_after"):
+                        text.append("\n  ")
+                        text.append("+ ", style=AFTER_STYLE)
+                        text.append(loc["fix_after"], style=AFTER_STYLE)
+
+        if poc_description:
+            text.append("\n\n")
+            text.append("PoC Description", style=FIELD_STYLE)
+            text.append("\n")
+            text.append(poc_description)
+
+        if poc_script_code:
+            text.append("\n\n")
+            text.append("PoC Code", style=FIELD_STYLE)
+            text.append("\n")
+            text.append_text(cls._highlight_python(poc_script_code))
+
+        if remediation_steps:
+            text.append("\n\n")
+            text.append("Remediation", style=FIELD_STYLE)
+            text.append("\n")
+            text.append(remediation_steps)
+
+        if not title:
+            text.append("\n  ")
+            text.append("Creating report...", style="dim")
+
+        padded = Text()
+        padded.append("\n\n")
+        padded.append_text(text)
+        padded.append("\n\n")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(padded, classes=css_classes)

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/thinking_renderer.py

@@ -0,0 +1,31 @@
+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 ThinkRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "think"
+    css_classes: ClassVar[list[str]] = ["tool-call", "thinking-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        thought = args.get("thought", "")
+
+        text = Text()
+        text.append("🧠 ")
+        text.append("Thinking", style="bold #a855f7")
+        text.append("\n  ")
+
+        if thought:
+            text.append(thought, style="italic dim")
+        else:
+            text.append("Thinking...", style="italic dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)

strix/interface/tool_components/todo_renderer.py

@@ -0,0 +1,225 @@
+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
+
+
+STATUS_MARKERS: dict[str, str] = {
+    "pending": "[ ]",
+    "in_progress": "[~]",
+    "done": "[•]",
+}
+
+
+def _format_todo_lines(text: Text, result: dict[str, Any]) -> None:
+    todos = result.get("todos")
+    if not isinstance(todos, list) or not todos:
+        text.append("\n  ")
+        text.append("No todos", style="dim")
+        return
+
+    for todo in todos:
+        status = todo.get("status", "pending")
+        marker = STATUS_MARKERS.get(status, STATUS_MARKERS["pending"])
+
+        title = todo.get("title", "").strip() or "(untitled)"
+
+        text.append("\n  ")
+        text.append(marker)
+        text.append(" ")
+
+        if status == "done":
+            text.append(title, style="dim strike")
+        elif status == "in_progress":
+            text.append(title, style="italic")
+        else:
+            text.append(title)
+
+
+@register_tool_renderer
+class CreateTodoRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "create_todo"
+    css_classes: ClassVar[list[str]] = ["tool-call", "todo-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        result = tool_data.get("result")
+
+        text = Text()
+        text.append("📋 ")
+        text.append("Todo", style="bold #a78bfa")
+
+        if isinstance(result, str) and result.strip():
+            text.append("\n  ")
+            text.append(result.strip(), style="dim")
+        elif result and isinstance(result, dict):
+            if result.get("success"):
+                _format_todo_lines(text, result)
+            else:
+                error = result.get("error", "Failed to create todo")
+                text.append("\n  ")
+                text.append(error, style="#ef4444")
+        else:
+            text.append("\n  ")
+            text.append("Creating...", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class ListTodosRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "list_todos"
+    css_classes: ClassVar[list[str]] = ["tool-call", "todo-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        result = tool_data.get("result")
+
+        text = Text()
+        text.append("📋 ")
+        text.append("Todos", style="bold #a78bfa")
+
+        if isinstance(result, str) and result.strip():
+            text.append("\n  ")
+            text.append(result.strip(), style="dim")
+        elif result and isinstance(result, dict):
+            if result.get("success"):
+                _format_todo_lines(text, result)
+            else:
+                error = result.get("error", "Unable to list todos")
+                text.append("\n  ")
+                text.append(error, style="#ef4444")
+        else:
+            text.append("\n  ")
+            text.append("Loading...", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class UpdateTodoRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "update_todo"
+    css_classes: ClassVar[list[str]] = ["tool-call", "todo-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        result = tool_data.get("result")
+
+        text = Text()
+        text.append("📋 ")
+        text.append("Todo Updated", style="bold #a78bfa")
+
+        if isinstance(result, str) and result.strip():
+            text.append("\n  ")
+            text.append(result.strip(), style="dim")
+        elif result and isinstance(result, dict):
+            if result.get("success"):
+                _format_todo_lines(text, result)
+            else:
+                error = result.get("error", "Failed to update todo")
+                text.append("\n  ")
+                text.append(error, style="#ef4444")
+        else:
+            text.append("\n  ")
+            text.append("Updating...", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class MarkTodoDoneRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "mark_todo_done"
+    css_classes: ClassVar[list[str]] = ["tool-call", "todo-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        result = tool_data.get("result")
+
+        text = Text()
+        text.append("📋 ")
+        text.append("Todo Completed", style="bold #a78bfa")
+
+        if isinstance(result, str) and result.strip():
+            text.append("\n  ")
+            text.append(result.strip(), style="dim")
+        elif result and isinstance(result, dict):
+            if result.get("success"):
+                _format_todo_lines(text, result)
+            else:
+                error = result.get("error", "Failed to mark todo done")
+                text.append("\n  ")
+                text.append(error, style="#ef4444")
+        else:
+            text.append("\n  ")
+            text.append("Marking done...", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class MarkTodoPendingRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "mark_todo_pending"
+    css_classes: ClassVar[list[str]] = ["tool-call", "todo-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        result = tool_data.get("result")
+
+        text = Text()
+        text.append("📋 ")
+        text.append("Todo Reopened", style="bold #f59e0b")
+
+        if isinstance(result, str) and result.strip():
+            text.append("\n  ")
+            text.append(result.strip(), style="dim")
+        elif result and isinstance(result, dict):
+            if result.get("success"):
+                _format_todo_lines(text, result)
+            else:
+                error = result.get("error", "Failed to reopen todo")
+                text.append("\n  ")
+                text.append(error, style="#ef4444")
+        else:
+            text.append("\n  ")
+            text.append("Reopening...", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)
+
+
+@register_tool_renderer
+class DeleteTodoRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "delete_todo"
+    css_classes: ClassVar[list[str]] = ["tool-call", "todo-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        result = tool_data.get("result")
+
+        text = Text()
+        text.append("📋 ")
+        text.append("Todo Removed", style="bold #94a3b8")
+
+        if isinstance(result, str) and result.strip():
+            text.append("\n  ")
+            text.append(result.strip(), style="dim")
+        elif result and isinstance(result, dict):
+            if result.get("success"):
+                _format_todo_lines(text, result)
+            else:
+                error = result.get("error", "Failed to remove todo")
+                text.append("\n  ")
+                text.append(error, style="#ef4444")
+        else:
+            text.append("\n  ")
+            text.append("Removing...", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)

strix/interface/tool_components/user_message_renderer.py

@@ -0,0 +1,50 @@
+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 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:
+            return Text()
+
+        return cls._format_user_message(content)
+
+    @classmethod
+    def _format_user_message(cls, content: str) -> Text:
+        text = Text()
+
+        text.append("▍", style="#3b82f6")
+        text.append(" ")
+        text.append("You:", style="bold")
+        text.append("\n")
+
+        lines = content.split("\n")
+        for i, line in enumerate(lines):
+            if i > 0:
+                text.append("\n")
+            text.append("▍", style="#3b82f6")
+            text.append(" ")
+            text.append(line)
+
+        return text

strix/interface/tool_components/web_search_renderer.py

@@ -0,0 +1,29 @@
+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 WebSearchRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "web_search"
+    css_classes: ClassVar[list[str]] = ["tool-call", "web-search-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        args = tool_data.get("args", {})
+        query = args.get("query", "")
+
+        text = Text()
+        text.append("🌐 ")
+        text.append("Searching the web...", style="bold #60a5fa")
+
+        if query:
+            text.append("\n  ")
+            text.append(query, style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)

strix/interface/tui/__init__.py

@@ -1,6 +0,0 @@
-"""Terminal user interface: Go/Bubble Tea frontend plus its Python runtime and backend."""
-
-from strix.interface.tui.live_view import TuiLiveView
-
-
-__all__ = ["TuiLiveView"]

strix/interface/tui/backend/__init__.py

@@ -1,7 +0,0 @@
-"""Backend bridge for external TUI clients."""
-
-from strix.interface.tui.backend.controller import TuiController
-from strix.interface.tui.backend.server import TuiBackendServer
-
-
-__all__ = ["TuiBackendServer", "TuiController"]

strix/interface/tui/backend/controller.py

@@ -1,488 +0,0 @@
-"""UI-independent state and command controller for interactive Strix clients."""
-
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import math
-import webbrowser
-from collections.abc import Awaitable, Callable
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-from strix.config import load_settings
-from strix.config.models import is_recommended_or_frontier_model
-from strix.config.settings import DEFAULT_MAX_TURNS
-from strix.interface.tui.backend.live_view import TuiLiveView
-from strix.interface.tui.backend.projection import (
-    MAX_TERMINAL_EVENTS,
-    MAX_TERMINAL_VULNERABILITIES,
-    SCAN_MODES,
-    SCOPE_MODES,
-    bounded_state_projection,
-    collection_item_projection,
-    sanitize_terminal_text,
-    terminal_projection,
-)
-from strix.interface.utils import is_subscription_run
-
-
-if TYPE_CHECKING:
-    import argparse
-
-    from strix.report.state import ReportState
-
-
-_STOPPABLE_AGENT_STATUSES = frozenset({"running", "waiting", "budget_paused"})
-
-ChangeCallback = Callable[[], None]
-StartCallback = Callable[[bool], Awaitable[None]]
-QuitCallback = Callable[[], Awaitable[None]]
-
-
-class TuiController:
-    """Own setup state and expose serializable scan state to any TUI."""
-
-    def __init__(
-        self,
-        args: argparse.Namespace,
-        *,
-        live_view: TuiLiveView | None = None,
-        coordinator: Any = None,
-        report_state: ReportState | None = None,
-        on_start: StartCallback | None = None,
-        on_quit: QuitCallback | None = None,
-        on_change: ChangeCallback | None = None,
-    ) -> None:
-        self.args = args
-        self.live_view = live_view or TuiLiveView()
-        self.coordinator = coordinator
-        self.report_state = report_state
-        self.scan_loop: asyncio.AbstractEventLoop | None = None
-        self.setup_mode = bool(args.needs_setup)
-        self.scan_started = not self.setup_mode
-        self._start_in_progress = False
-        self.scan_state = "setup" if self.setup_mode else "running"
-        self.targets = [
-            str(target["original"])
-            for target in args.targets_info
-            if isinstance(target, dict) and target.get("original")
-        ]
-        instruction = args.instruction
-        self.instruction = instruction.strip() if isinstance(instruction, str) else ""
-        requested_scan_mode = str(args.scan_mode)
-        self.scan_mode = requested_scan_mode if requested_scan_mode in SCAN_MODES else "deep"
-        raw_budget = args.max_budget_usd
-        self.max_budget_usd = (
-            float(raw_budget)
-            if isinstance(raw_budget, int | float)
-            and not isinstance(raw_budget, bool)
-            and math.isfinite(float(raw_budget))
-            and raw_budget > 0
-            else None
-        )
-        raw_turns = args.max_turns
-        self.max_turns = (
-            raw_turns
-            if isinstance(raw_turns, int) and not isinstance(raw_turns, bool) and raw_turns > 0
-            else DEFAULT_MAX_TURNS
-        )
-        requested_scope = str(args.scope_mode)
-        self.scope_mode = requested_scope if requested_scope in SCOPE_MODES else "auto"
-        raw_diff_base = args.diff_base
-        self.diff_base = raw_diff_base.strip() if isinstance(raw_diff_base, str) else None
-        # Host directory mounted for the agent to work in when the scan has no
-        # target, set only once the user confirms it. It is a workspace, not a
-        # target: it carries no scan scope, and the instruction is the only
-        # source of truth for what to do.
-        self.workspace_mount: str | None = None
-        # A target-less launch enters the live view and asks there before
-        # anything is prepared; this holds the directory awaiting that answer.
-        self.pending_workspace_mount: str | None = None
-        self._pending_verify = True
-        self.messages: list[dict[str, str]] = []
-        self._next_message_id = 1
-        self.error: str | None = None
-        self.viewer_status = "idle"
-        self.viewer_url: str | None = None
-        self._viewer_httpd: Any = None
-        self._on_start = on_start
-        self._on_quit = on_quit
-        self._on_change = on_change
-
-    def set_change_callback(self, callback: ChangeCallback) -> None:
-        self._on_change = callback
-
-    def notify_changed(self) -> None:
-        if self._on_change is not None:
-            self._on_change()
-
-    def set_runtime(
-        self,
-        *,
-        report_state: ReportState | None = None,
-        scan_loop: asyncio.AbstractEventLoop | None = None,
-    ) -> None:
-        if report_state is not None:
-            self.report_state = report_state
-        if scan_loop is not None:
-            self.scan_loop = scan_loop
-
-    def begin_preparation(self) -> None:
-        """Mark a directly-launched run as preparing behind the live TUI."""
-        self.scan_state = "preparing"
-        self.notify_changed()
-
-    def fail_preparation(self, detail: str) -> None:
-        self.scan_state = "failed"
-        self.error = detail
-        self.notify_changed()
-
-    def add_message(self, text: str, level: str = "info") -> None:
-        self._append_message(text, level)
-        self.notify_changed()
-
-    def _append_message(self, text: str, level: str) -> None:
-        self.messages.append(
-            {
-                "id": f"message-{self._next_message_id}",
-                "text": sanitize_terminal_text(text),
-                "level": sanitize_terminal_text(level),
-            }
-        )
-        self._next_message_id += 1
-        self.messages = self.messages[-200:]
-
-    def snapshot(self) -> dict[str, Any]:
-        """Return small mutable state; histories are streamed as collections."""
-        model = ""
-        with contextlib.suppress(Exception):
-            model = (load_settings().llm.model or "").strip()
-        usage: dict[str, Any] = {}
-        if self.report_state is not None:
-            usage = dict(self.report_state.get_total_llm_usage())
-        subscription = False
-        with contextlib.suppress(Exception):
-            subscription = is_subscription_run(self.report_state)
-        model_warning = ""
-        if model and not is_recommended_or_frontier_model(model):
-            model_warning = (
-                f"{model} is not a recommended frontier model; pentest quality could be degraded"
-            )
-        state = {
-            "setup_mode": self.setup_mode,
-            "scan_started": self.scan_started,
-            "scan_state": self.scan_state,
-            "targets": [
-                terminal_projection(target, max_string=128) for target in self.targets[:16]
-            ],
-            "target_count": len(self.targets),
-            "working_dir": str(Path.cwd()),
-            "pending_mount": self.pending_workspace_mount or "",
-            "instruction": terminal_projection(self.instruction, max_string=2 * 1024),
-            "scan_mode": self.scan_mode,
-            "max_budget_usd": self.max_budget_usd,
-            "max_turns": self.max_turns,
-            "scope_mode": self.scope_mode,
-            "diff_base": terminal_projection(self.diff_base, max_string=256),
-            "model": terminal_projection(model, max_string=256),
-            "model_warning": terminal_projection(model_warning, max_string=512),
-            "caido_url": terminal_projection(
-                getattr(self.report_state, "caido_url", None), max_string=1024
-            ),
-            "messages": [
-                {
-                    "id": str(message.get("id", ""))[:64],
-                    "text": terminal_projection(message.get("text", ""), max_string=256),
-                    "level": str(message.get("level", "info"))[:32],
-                }
-                for message in self.messages[-10:]
-            ],
-            "usage": terminal_projection(usage, max_string=256, max_items=20),
-            "subscription": subscription,
-            "viewer_status": self.viewer_status,
-            "viewer_url": terminal_projection(self.viewer_url, max_string=1024),
-            "error": terminal_projection(self.error, max_string=2 * 1024),
-        }
-        return bounded_state_projection(state)
-
-    def collection(self, name: str) -> list[dict[str, Any]]:
-        """Return one bounded terminal projection with stable item identities."""
-        if name == "agents":
-            return [
-                {
-                    key: terminal_projection(agent.get(key), max_string=256, max_items=5)
-                    for key in (
-                        "id",
-                        "name",
-                        "parent_id",
-                        "status",
-                        "error_message",
-                        "created_at",
-                        "updated_at",
-                    )
-                    if key in agent
-                }
-                for agent in self.live_view.agents.values()
-            ]
-        if name == "events":
-            return [collection_item_projection(event) for event in self.live_view.events]
-        if name == "vulnerabilities":
-            reports = (
-                self.report_state.vulnerability_reports if self.report_state is not None else []
-            )[-MAX_TERMINAL_VULNERABILITIES:]
-            result: list[dict[str, Any]] = []
-            for index, report in enumerate(reports):
-                projected = collection_item_projection(report)
-                report_id = projected.get("id")
-                if not isinstance(report_id, str) or not report_id:
-                    projected["id"] = f"vulnerability-{index}"
-                result.append(projected)
-            return result
-        raise ValueError(f"Unknown collection: {name}")
-
-    def collection_snapshot(self, name: str) -> tuple[int | None, list[dict[str, Any]]]:
-        """Return a collection cursor and complete bounded projection."""
-        if name == "events":
-            cursor, events = self.live_view.event_snapshot(limit=MAX_TERMINAL_EVENTS)
-            return cursor, [collection_item_projection(event) for event in events]
-        return None, self.collection(name)
-
-    def collection_changes(
-        self,
-        name: str,
-        cursor: int,
-    ) -> tuple[int, list[dict[str, Any]]]:
-        """Return event upserts since a monotonic source cursor."""
-        if name != "events":
-            raise ValueError(f"Collection {name!r} does not expose incremental changes")
-        next_cursor, events = self.live_view.event_changes_since(cursor)
-        return next_cursor, [
-            collection_item_projection(event) for event in events[-MAX_TERMINAL_EVENTS:]
-        ]
-
-    async def handle(self, command: str, payload: dict[str, Any]) -> dict[str, Any]:
-        handlers = {
-            "setup.add_target": self._add_target,
-            "setup.set_instruction": self._set_instruction,
-            "setup.start": self._start,
-            "setup.confirm_mount": self._confirm_mount,
-            "agent.send_message": self._send_message,
-            "agent.stop": self._stop_agent,
-            "viewer.open": self._open_viewer,
-            "app.quit": self._quit,
-        }
-        handler = handlers.get(command)
-        if handler is None:
-            raise ValueError(f"Unknown command: {command}")
-        result = await handler(payload)
-        self.notify_changed()
-        return result
-
-    async def _add_target(self, payload: dict[str, Any]) -> dict[str, Any]:
-        self._require_setup_mutable()
-        target = self._required_string(payload, "target")
-        if target not in self.targets:
-            self.targets.append(target)
-        return {"target": target, "total": len(self.targets)}
-
-    async def _set_instruction(self, payload: dict[str, Any]) -> dict[str, Any]:
-        self._require_setup_mutable()
-        instruction = payload.get("instruction", "")
-        if not isinstance(instruction, str):
-            raise TypeError("instruction must be a string")
-        self.instruction = instruction.strip()
-        return {"instruction": self.instruction}
-
-    async def _start(self, payload: dict[str, Any]) -> dict[str, Any]:
-        if self.scan_started or self._start_in_progress:
-            raise RuntimeError("Scan is already starting or running")
-        # A bare prompt launches optimistically, like a coding agent: it skips
-        # the network model preflight and surfaces any model error live. A named
-        # target keeps the preflight so a real scan does not commit blind.
-        verify = payload.get("verify", True)
-        if not isinstance(verify, bool):
-            raise TypeError("verify must be a boolean")
-        # Launching with no target mounts the working directory, so it requires
-        # the user's explicit confirmation rather than happening silently.
-        mount_working_dir = payload.get("mount_working_dir", False)
-        if not isinstance(mount_working_dir, bool):
-            raise TypeError("mount_working_dir must be a boolean")
-        model = (load_settings().llm.model or "").strip()
-        if not model:
-            raise ValueError("No model configured. Set STRIX_LLM first.")
-        if self._on_start is None:
-            raise RuntimeError("Scan start is unavailable")
-        if not self.targets:
-            if not mount_working_dir:
-                raise ValueError("No target set. Add a target first.")
-            # Mounting the working directory needs the user's confirmation, and
-            # that is asked in the live view. Enter it now and prepare nothing
-            # until the answer arrives, so declining leaves no run behind.
-            self.pending_workspace_mount = str(Path.cwd())
-            self._pending_verify = verify
-            self.setup_mode = False
-            self.scan_started = True
-            self.scan_state = "preparing"
-            return {"started": True}
-        await self._begin_scan(verify)
-        return {"started": True}
-
-    async def _begin_scan(self, verify: bool) -> None:
-        if self._on_start is None:
-            raise RuntimeError("Scan start is unavailable")
-        self._start_in_progress = True
-        try:
-            await self._on_start(verify)
-        finally:
-            self._start_in_progress = False
-        self.setup_mode = False
-        self.scan_started = True
-        self.scan_state = "running"
-
-    async def _confirm_mount(self, payload: dict[str, Any]) -> dict[str, Any]:
-        """Answer the pending working-directory mount asked for in the live view."""
-        mount = self.pending_workspace_mount
-        if mount is None:
-            raise RuntimeError("No mount confirmation is pending")
-        approved = payload.get("approved")
-        if not isinstance(approved, bool):
-            raise TypeError("approved must be a boolean")
-        self.pending_workspace_mount = None
-        # Declining skips the mount, it does not abandon the scan. The prompt is
-        # the whole of the input either way; the working directory is only an
-        # extra the agent may look at, so the run goes ahead without one.
-        self.workspace_mount = mount if approved else None
-        await self._begin_scan(self._pending_verify)
-        return {"approved": approved}
-
-    async def _send_message(self, payload: dict[str, Any]) -> dict[str, Any]:
-        agent_id = self._required_string(payload, "agent_id")
-        message = self._required_string(payload, "message")
-        if self.coordinator is None:
-            raise RuntimeError("Agent coordinator is unavailable")
-        if self.scan_loop is None or self.scan_loop.is_closed():
-            raise RuntimeError("Scan loop is not ready")
-        self.live_view.record_user_message(agent_id, message)
-        if self.scan_loop is asyncio.get_running_loop():
-            delivered = await self.coordinator.send(
-                agent_id,
-                {"from": "user", "content": message, "type": "instruction"},
-            )
-        else:
-            future = asyncio.run_coroutine_threadsafe(
-                self.coordinator.send(
-                    agent_id,
-                    {"from": "user", "content": message, "type": "instruction"},
-                ),
-                self.scan_loop,
-            )
-            delivered = await asyncio.wrap_future(future)
-        if not delivered:
-            raise RuntimeError("Message could not be delivered")
-        return {"sent": True}
-
-    async def _stop_agent(self, payload: dict[str, Any]) -> dict[str, Any]:
-        agent_id = self._required_string(payload, "agent_id")
-        agent = self.live_view.agents.get(agent_id)
-        if agent is None:
-            raise ValueError(f"Unknown agent: {agent_id}")
-        status = str(agent.get("status", ""))
-        if status not in _STOPPABLE_AGENT_STATUSES:
-            raise RuntimeError(f"Agent '{agent_id}' cannot be stopped while {status or 'unknown'}")
-        if self.coordinator is None or self.scan_loop is None or self.scan_loop.is_closed():
-            raise RuntimeError("Scan loop is not ready")
-        if self.scan_loop is asyncio.get_running_loop():
-            accepted = await self.coordinator.cancel_descendants_graceful(agent_id)
-        else:
-            future = asyncio.run_coroutine_threadsafe(
-                self.coordinator.cancel_descendants_graceful(agent_id), self.scan_loop
-            )
-            accepted = await asyncio.wrap_future(future)
-        if not accepted:
-            raise RuntimeError(f"Agent '{agent_id}' is no longer active")
-        return {"stopped": True}
-
-    async def _open_viewer(self, _payload: dict[str, Any]) -> dict[str, Any]:
-        if self.viewer_url:
-            with contextlib.suppress(Exception):
-                webbrowser.open(self.viewer_url)
-            return {"status": "running", "url": self.viewer_url}
-        if self.report_state is None:
-            self.viewer_status = "failed"
-            return {"status": self.viewer_status, "error": "Scan output is not ready"}
-        try:
-            from strix.interface.tui.backend.messages import (
-                send_user_message_to_agent,
-            )
-            from strix.interface.viewer.server import (
-                authorized_url,
-                bundle_is_built,
-                serve,
-            )
-
-            if not bundle_is_built():
-                self.viewer_status = "unavailable"
-                return {"status": self.viewer_status, "error": "Viewer UI not built"}
-
-            def steer(agent_id: str, message: str) -> bool:
-                return send_user_message_to_agent(
-                    coordinator=self.coordinator,
-                    loop=self.scan_loop,
-                    live_view=self.live_view,
-                    target_agent_id=agent_id,
-                    message=message,
-                    notify_changed=self.notify_changed,
-                    wait_for_delivery=True,
-                )
-
-            httpd, url, token = serve(
-                self.report_state.get_run_dir(),
-                open_browser=True,
-                steer_handler=steer,
-            )
-            self._viewer_httpd = httpd
-            self.viewer_url = authorized_url(url, token)
-            self.viewer_status = "running"
-            with contextlib.suppress(Exception):
-                from strix.telemetry import posthog
-
-                live = self.report_state.run_record.get("status") not in {
-                    "completed",
-                    "stopped",
-                    "failed",
-                    "interrupted",
-                }
-                posthog.viewer_opened(source="tui", live=live)
-        except Exception:  # noqa: BLE001 - viewer startup failures must not crash the TUI
-            self.viewer_status = "failed"
-            return {"status": self.viewer_status, "error": "Viewer failed to start"}
-        else:
-            return {"status": self.viewer_status, "url": self.viewer_url}
-
-    def close_viewer(self) -> None:
-        httpd = self._viewer_httpd
-        if httpd is None:
-            return
-        self._viewer_httpd = None
-        with contextlib.suppress(Exception):
-            httpd.shutdown()
-            httpd.server_close()
-
-    async def _quit(self, _payload: dict[str, Any]) -> dict[str, Any]:
-        self.close_viewer()
-        if self._on_quit is not None:
-            await self._on_quit()
-        self.scan_state = "stopped"
-        return {"quitting": True}
-
-    @staticmethod
-    def _required_string(payload: dict[str, Any], name: str) -> str:
-        value = payload.get(name)
-        if not isinstance(value, str) or not value.strip():
-            raise ValueError(f"{name} must be a non-empty string")
-        return value.strip()
-
-    def _require_setup_mutable(self) -> None:
-        if not self.setup_mode or self.scan_started or self._start_in_progress:
-            raise RuntimeError("Setup can no longer be changed after the scan starts")

strix/interface/tui/backend/live_view.py

@@ -1,136 +0,0 @@
-"""Go-TUI event projection layered on the shared base projection."""
-
-from __future__ import annotations
-
-from datetime import UTC, datetime
-from typing import Any
-
-from strix.interface.tui.live_view import TuiLiveView as BaseLiveView
-
-
-_MAX_LIVE_EVENTS = 10_000
-
-
-class TuiLiveView(BaseLiveView):
-    """Add protocol cursors and bounds on top of the shared projection state."""
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._event_cursor = 0
-        self._event_change_cursor: dict[str, int] = {}
-        self._events_by_id: dict[str, dict[str, Any]] = {}
-
-    def upsert_agent(  # type: ignore[override]
-        self,
-        agent_id: str,
-        *,
-        name: str | None = None,
-        parent_id: str | None = None,
-        status: str | None = None,
-        error_message: str | None = None,
-    ) -> bool:
-        now = datetime.now(UTC).isoformat()
-        current = self.agents.get(agent_id)
-        if current is None:
-            current = {
-                "id": agent_id,
-                "name": name or agent_id,
-                "parent_id": parent_id,
-                "status": status or "running",
-                "created_at": now,
-                "updated_at": now,
-            }
-            if error_message:
-                current["error_message"] = error_message
-            self.agents[agent_id] = current
-            return True
-
-        changed = False
-        if name is not None and current.get("name") != name:
-            current["name"] = name
-            changed = True
-        if (parent_id is not None or "parent_id" not in current) and current.get(
-            "parent_id"
-        ) != parent_id:
-            current["parent_id"] = parent_id
-            changed = True
-        if status is not None and current.get("status") != status:
-            current["status"] = status
-            changed = True
-        if error_message and current.get("error_message") != error_message:
-            current["error_message"] = error_message
-            changed = True
-        if changed:
-            current["updated_at"] = now
-        return changed
-
-    def _append_event(
-        self,
-        agent_id: str,
-        event_type: str,
-        data: dict[str, Any],
-        *,
-        timestamp: str | None = None,
-    ) -> dict[str, Any]:
-        event = super()._append_event(
-            agent_id,
-            event_type,
-            data,
-            timestamp=timestamp,
-        )
-        self._events_by_id[event["id"]] = event
-        self._mark_event_changed(event)
-        if len(self.events) > _MAX_LIVE_EVENTS:
-            removed = self.events.pop(0)
-            removed_id = str(removed.get("id", ""))
-            self._events_by_id.pop(removed_id, None)
-            self._event_change_cursor.pop(removed_id, None)
-            self._open_assistant_event_by_agent = {
-                current_agent_id: current
-                for current_agent_id, current in self._open_assistant_event_by_agent.items()
-                if current is not removed
-            }
-            self._tool_event_by_agent_and_call_id = {
-                key: current
-                for key, current in self._tool_event_by_agent_and_call_id.items()
-                if current is not removed
-            }
-        return event
-
-    def _bump_event(  # type: ignore[override]
-        self,
-        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()
-        self._mark_event_changed(event)
-
-    def _mark_event_changed(self, event: dict[str, Any]) -> None:
-        event_id = event.get("id")
-        if not isinstance(event_id, str) or not event_id:
-            return
-        self._event_cursor += 1
-        self._event_change_cursor[event_id] = self._event_cursor
-
-    def event_snapshot(self, *, limit: int | None = None) -> tuple[int, list[dict[str, Any]]]:
-        events = self.events[-limit:] if limit is not None else self.events
-        return self._event_cursor, list(events)
-
-    def event_changes_since(self, cursor: int) -> tuple[int, list[dict[str, Any]]]:
-        if cursor < 0 or cursor > self._event_cursor:
-            raise ValueError("event cursor is outside the available history")
-        changed_ids = sorted(
-            (
-                (change_cursor, event_id)
-                for event_id, change_cursor in self._event_change_cursor.items()
-                if change_cursor > cursor
-            )
-        )
-        changed = [
-            self._events_by_id[event_id]
-            for _change_cursor, event_id in changed_ids
-            if event_id in self._events_by_id
-        ]
-        return self._event_cursor, changed

strix/interface/tui/backend/messages.py

@@ -1,61 +0,0 @@
-"""Confirmed message delivery for non-Textual interactive clients."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import TYPE_CHECKING, Any
-
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-
-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,
-    notify_changed: Callable[[], None] | None = None,
-    wait_for_delivery: bool = False,
-) -> bool:
-    if loop is None or loop.is_closed():
-        return False
-
-    async def deliver() -> bool:
-        delivered = bool(
-            await coordinator.send(
-                target_agent_id,
-                {"from": "user", "content": message, "type": "instruction"},
-            )
-        )
-        if delivered:
-            live_view.record_user_message(target_agent_id, message)
-            if notify_changed is not None:
-                notify_changed()
-        return delivered
-
-    future = asyncio.run_coroutine_threadsafe(deliver(), loop)
-    if wait_for_delivery:
-        try:
-            return bool(future.result(timeout=10))
-        except Exception:
-            logger.exception("TUI user message delivery failed")
-            return False
-    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/backend/projection.py

@@ -1,182 +0,0 @@
-"""Wire-safe projections of runtime state for the TUI backend."""
-
-from __future__ import annotations
-
-import json
-import re
-from typing import Any
-
-
-SCAN_MODES = ("quick", "standard", "deep")
-SCOPE_MODES = ("auto", "diff", "full")
-MAX_PROJECTION_STRING = 64 * 1024
-MAX_IMAGE_DATA_URI_BYTES = 2 * 1024 * 1024
-MAX_COLLECTION_ITEM_BYTES = 512 * 1024
-MAX_TERMINAL_EVENTS = 5_000
-MAX_TERMINAL_VULNERABILITIES = 1_000
-STATE_TARGET_BYTES = 48 * 1024
-TERMINAL_ESCAPE_RE = re.compile(r"\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-_][0-?]*[ -/]*[@-~]")
-
-
-def sanitize_terminal_text(value: str) -> str:
-    without_escapes = TERMINAL_ESCAPE_RE.sub("", value)
-    return "".join(
-        character
-        for character in without_escapes
-        if character in "\n\t" or (ord(character) >= 32 and not 127 <= ord(character) <= 159)
-    )
-
-
-def terminal_projection(  # noqa: PLR0911
-    value: Any,
-    *,
-    max_string: int = MAX_PROJECTION_STRING,
-    max_items: int = 200,
-    depth: int = 0,
-) -> Any:
-    """Copy and bound terminal-only data without changing durable history."""
-    if isinstance(value, str):
-        if value.startswith("data:image/"):
-            if len(value) <= MAX_IMAGE_DATA_URI_BYTES:
-                return value
-            return "[image omitted from terminal projection]"
-        clean = sanitize_terminal_text(value)
-        if len(clean) <= max_string:
-            return clean
-        omitted = len(clean) - max_string
-        return f"{clean[:max_string]}\n...[{omitted} characters omitted from terminal projection]"
-    if value is None or isinstance(value, bool | int | float):
-        return value
-    if depth >= 8:
-        return "[nested value omitted from terminal projection]"
-    if isinstance(value, dict):
-        items = list(value.items())
-        projected = {
-            sanitize_terminal_text(str(key)): terminal_projection(
-                item,
-                max_string=max_string,
-                max_items=max_items,
-                depth=depth + 1,
-            )
-            for key, item in items[:max_items]
-        }
-        if len(items) > max_items:
-            projected["_projection_notice"] = (
-                f"{len(items) - max_items} fields omitted from terminal projection"
-            )
-        return projected
-    if isinstance(value, list | tuple):
-        projected_items = [
-            terminal_projection(
-                item,
-                max_string=max_string,
-                max_items=max_items,
-                depth=depth + 1,
-            )
-            for item in value[:max_items]
-        ]
-        if len(value) > max_items:
-            projected_items.append(
-                f"[{len(value) - max_items} items omitted from terminal projection]"
-            )
-        return projected_items
-    return terminal_projection(
-        str(value),
-        max_string=max_string,
-        max_items=max_items,
-        depth=depth,
-    )
-
-
-def collection_item_projection(item: dict[str, Any]) -> dict[str, Any]:
-    # Image data URIs are exempt from string truncation, so grant them their
-    # own byte budget on top of the regular per-item budget.
-    item_budget = MAX_COLLECTION_ITEM_BYTES + MAX_IMAGE_DATA_URI_BYTES
-    projected = terminal_projection(item)
-    assert isinstance(projected, dict)
-    if len(json.dumps(projected, default=str, separators=(",", ":")).encode()) <= item_budget:
-        return projected
-
-    projected = terminal_projection(item, max_string=8 * 1024, max_items=40)
-    assert isinstance(projected, dict)
-    projected["projection_truncated"] = True
-    if len(json.dumps(projected, default=str, separators=(",", ":")).encode()) <= item_budget:
-        return projected
-
-    # Preserve identity and useful summary fields even for pathological nested
-    # tool output or finding evidence.
-    compact: dict[str, Any] = {
-        key: terminal_projection(item[key], max_string=8 * 1024, max_items=10)
-        for key in (
-            "id",
-            "version",
-            "type",
-            "agent_id",
-            "timestamp",
-            "title",
-            "severity",
-            "description",
-        )
-        if key in item
-    }
-    compact["projection_truncated"] = True
-    return compact
-
-
-def bounded_state_projection(state: dict[str, Any]) -> dict[str, Any]:
-    """Keep mutable control state comfortably below the 64 KiB frame limit."""
-
-    def encoded_size(value: dict[str, Any]) -> int:
-        return len(
-            json.dumps(value, default=str, ensure_ascii=False, separators=(",", ":")).encode()
-        )
-
-    if encoded_size(state) <= STATE_TARGET_BYTES:
-        return state
-
-    state["projection_truncated"] = True
-    state["targets"] = [
-        terminal_projection(target, max_string=64) for target in state["targets"][:8]
-    ]
-    state["instruction"] = terminal_projection(state["instruction"], max_string=512)
-    state["messages"] = [
-        {
-            **message,
-            "text": terminal_projection(message.get("text", ""), max_string=128),
-        }
-        for message in state["messages"][-5:]
-    ]
-    state["usage"] = {}
-    state["error"] = terminal_projection(state["error"], max_string=512)
-    state["model_warning"] = terminal_projection(state["model_warning"], max_string=256)
-    state["caido_url"] = terminal_projection(state["caido_url"], max_string=256)
-    state["viewer_url"] = terminal_projection(state["viewer_url"], max_string=256)
-    if encoded_size(state) <= STATE_TARGET_BYTES:
-        return state
-
-    # Defensive final projection: use an explicit schema so future snapshot
-    # fields cannot silently bypass the aggregate byte budget.
-    return {
-        "setup_mode": state["setup_mode"],
-        "scan_started": state["scan_started"],
-        "scan_state": state["scan_state"],
-        "targets": state["targets"][:4],
-        "target_count": state["target_count"],
-        "instruction": terminal_projection(state["instruction"], max_string=128),
-        "scan_mode": state["scan_mode"],
-        "max_budget_usd": state["max_budget_usd"],
-        "max_turns": state["max_turns"],
-        "scope_mode": state["scope_mode"],
-        "diff_base": state["diff_base"],
-        "provider": state["provider"],
-        "model": state["model"],
-        "model_warning": "",
-        "caido_url": None,
-        "messages": [],
-        "usage": {},
-        "subscription": state["subscription"],
-        "viewer_status": state["viewer_status"],
-        "viewer_url": None,
-        "error": terminal_projection(state["error"], max_string=256),
-        "projection_truncated": True,
-    }

strix/interface/tui/backend/protocol.py

@@ -1,40 +0,0 @@
-"""Versioned JSON protocol shared with the Go TUI."""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-PROTOCOL_VERSION = 3
-PROTOCOL_CAPABILITIES = (
-    "state-revisions",
-    "collection-deltas",
-    "structured-command-errors",
-    "agents-collection",
-)
-
-# Commands and control messages are intentionally small. Event and finding
-# history uses a separate bounded collection stream so a resumed run can be
-# larger than any individual frame.
-MAX_COMMAND_BYTES = 64 * 1024
-MAX_COLLECTION_FRAME_BYTES = 4 * 1024 * 1024
-
-
-class ProtocolHandshakeError(RuntimeError):
-    """Raised before the Go TUI is activated when v3 negotiation fails."""
-
-
-def envelope(
-    message_type: str,
-    payload: dict[str, Any],
-    *,
-    request_id: str | None = None,
-) -> dict[str, Any]:
-    message: dict[str, Any] = {
-        "version": PROTOCOL_VERSION,
-        "type": message_type,
-        "payload": payload,
-    }
-    if request_id:
-        message["request_id"] = request_id
-    return message

strix/interface/tui/backend/server.py

@@ -1,531 +0,0 @@
-"""Private framed IPC connection used by the Go TUI."""
-
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import json
-import logging
-import struct
-from collections import deque
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
-
-from strix.interface.tui.backend.projection import sanitize_terminal_text
-from strix.interface.tui.backend.protocol import (
-    MAX_COLLECTION_FRAME_BYTES,
-    MAX_COMMAND_BYTES,
-    PROTOCOL_CAPABILITIES,
-    PROTOCOL_VERSION,
-    ProtocolHandshakeError,
-    envelope,
-)
-
-
-if TYPE_CHECKING:
-    import socket
-
-    from strix.interface.tui.backend.controller import TuiController
-
-logger = logging.getLogger(__name__)
-
-_HEADER = struct.Struct(">I")
-_HANDSHAKE_TIMEOUT = 10.0
-_COLLECTIONS = ("agents", "events", "vulnerabilities")
-_COLLECTION_ITEM_LIMITS = {"events": 5_000, "vulnerabilities": 1_000}
-# Leave enough room for the collection envelope and cursor metadata.
-_COLLECTION_PAYLOAD_TARGET = MAX_COLLECTION_FRAME_BYTES - 16 * 1024
-
-
-class _MessageTooLargeError(ValueError):
-    pass
-
-
-@dataclass
-class _CollectionState:
-    revision: int = 0
-    bootstrapped: bool = False
-    order: list[str] = field(default_factory=list)
-    items: dict[str, dict[str, Any]] = field(default_factory=dict)
-    fingerprints: dict[str, str] = field(default_factory=dict)
-    source_cursor: int | None = None
-
-
-class TuiBackendServer:
-    """Serve one TUI child over an authenticated, connected socket."""
-
-    def __init__(self, controller: TuiController) -> None:
-        self.controller = controller
-        self._socket: socket.socket | None = None
-        self._reader_task: asyncio.Task[None] | None = None
-        self._broadcast_event = asyncio.Event()
-        self._broadcast_task: asyncio.Task[None] | None = None
-        self._write_lock = asyncio.Lock()
-        self._sync_lock = asyncio.Lock()
-        self._state_revision = 0
-        self._state_fingerprint = ""
-        self._collections = {name: _CollectionState() for name in _COLLECTIONS}
-        self._seen_request_ids: set[str] = set()
-        self._request_id_order: deque[str] = deque()
-        self.activated = False
-        controller.set_change_callback(self.notify_changed)
-
-    async def start(self, connection: socket.socket) -> None:
-        """Negotiate protocol v3 before activating command or state traffic."""
-        if self._socket is not None:
-            raise RuntimeError("TUI backend is already started")
-        connection.setblocking(False)  # noqa: FBT003
-        self._socket = connection
-        try:
-            await self._send(envelope("hello", {"capabilities": list(PROTOCOL_CAPABILITIES)}))
-            await asyncio.wait_for(self._receive_ready(), timeout=_HANDSHAKE_TIMEOUT)
-        except TimeoutError as exc:
-            raise ProtocolHandshakeError("Timed out waiting for TUI protocol ready") from exc
-        except (EOFError, ConnectionError, OSError) as exc:
-            raise ProtocolHandshakeError(f"TUI closed during protocol handshake: {exc}") from exc
-        except (TypeError, ValueError, json.JSONDecodeError, UnicodeDecodeError) as exc:
-            raise ProtocolHandshakeError(str(exc)) from exc
-
-        self.activated = True
-        self._reader_task = asyncio.create_task(self._read_loop())
-        self._broadcast_task = asyncio.create_task(self._broadcast_loop())
-        self.notify_changed()
-
-    async def close(self) -> None:
-        tasks = [task for task in (self._reader_task, self._broadcast_task) if task is not None]
-        for task in tasks:
-            task.cancel()
-        for task in tasks:
-            if task is asyncio.current_task():
-                continue
-            with contextlib.suppress(asyncio.CancelledError):
-                await task
-        self._reader_task = None
-        self._broadcast_task = None
-        self._close_socket()
-
-    def _close_socket(self) -> None:
-        if self._socket is not None:
-            self._socket.close()
-            self._socket = None
-
-    def notify_changed(self) -> None:
-        if self.activated:
-            self._broadcast_event.set()
-
-    async def _read_exactly(self, size: int) -> bytes:
-        connection = self._socket
-        if connection is None:
-            raise ConnectionError("TUI IPC connection is closed")
-        loop = asyncio.get_running_loop()
-        chunks: list[bytes] = []
-        remaining = size
-        while remaining:
-            chunk = await loop.sock_recv(connection, remaining)
-            if not chunk:
-                raise EOFError("TUI IPC peer closed")
-            chunks.append(chunk)
-            remaining -= len(chunk)
-        return b"".join(chunks)
-
-    async def _read_frame(self, maximum: int) -> bytes:
-        (size,) = _HEADER.unpack(await self._read_exactly(_HEADER.size))
-        if size == 0 or size > maximum:
-            # Reject the length before allocating or reading its payload.
-            raise ConnectionError(f"invalid TUI IPC frame size: {size}")
-        return await self._read_exactly(size)
-
-    async def _receive_ready(self) -> None:
-        raw = await self._read_frame(MAX_COMMAND_BYTES)
-        message = json.loads(raw.decode("utf-8"))
-        if not isinstance(message, dict):
-            raise TypeError("TUI ready message must be an object")
-        if message.get("version") != PROTOCOL_VERSION:
-            raise ValueError(
-                f"TUI protocol mismatch: expected v{PROTOCOL_VERSION}, "
-                f"received v{message.get('version')}"
-            )
-        if message.get("type") != "ready":
-            raise ValueError("TUI protocol handshake expected ready")
-        payload = message.get("payload")
-        if not isinstance(payload, dict):
-            raise TypeError("TUI ready payload must be an object")
-        capabilities = payload.get("capabilities")
-        if capabilities != list(PROTOCOL_CAPABILITIES):
-            raise ValueError("TUI protocol capability mismatch")
-
-    async def _read_loop(self) -> None:
-        try:
-            while True:
-                raw = await self._read_frame(MAX_COMMAND_BYTES)
-                response, resync = await self._handle_message(raw)
-                if response is not None:
-                    await self._send_command_response(response)
-                if resync is not None:
-                    await self._resync_collection(resync)
-        except asyncio.CancelledError:
-            raise
-        except (EOFError, ConnectionError, OSError):
-            self._close_socket()
-
-    @staticmethod
-    def _decode_message(raw: bytes) -> tuple[str, str, dict[str, object]]:
-        message = json.loads(raw.decode("utf-8"))
-        if not isinstance(message, dict):
-            raise TypeError("message must be an object")
-        request_id = message.get("request_id")
-        if not isinstance(request_id, str) or not request_id:
-            raise ValueError("command request_id must be a non-empty string")
-        if message.get("version") != PROTOCOL_VERSION:
-            raise ValueError(f"unsupported protocol version; expected {PROTOCOL_VERSION}")
-        command = message.get("type")
-        payload = message.get("payload", {})
-        if not isinstance(command, str) or not isinstance(payload, dict):
-            raise TypeError("invalid command envelope")
-        if len(command) > 128:
-            raise ValueError("command name exceeds 128 characters")
-        return request_id, command, payload
-
-    @staticmethod
-    def _structured_error(exc: Exception) -> dict[str, object]:
-        if isinstance(exc, OSError):
-            return {"code": "persistence_error", "message": str(exc), "retryable": True}
-        if isinstance(exc, TypeError | ValueError | json.JSONDecodeError | UnicodeDecodeError):
-            return {"code": "invalid_request", "message": str(exc), "retryable": False}
-        if isinstance(exc, RuntimeError):
-            return {"code": "command_failed", "message": str(exc), "retryable": False}
-        logger.exception("Unhandled TUI command error", exc_info=exc)
-        return {
-            "code": "internal_error",
-            "message": "The command failed unexpectedly",
-            "retryable": True,
-        }
-
-    async def _handle_message(self, raw: bytes) -> tuple[dict[str, Any] | None, str | None]:
-        request_id: str | None = None
-        command = ""
-        resync: str | None = None
-        try:
-            preliminary = json.loads(raw.decode("utf-8"))
-            if isinstance(preliminary, dict):
-                raw_request_id = preliminary.get("request_id")
-                if isinstance(raw_request_id, str) and raw_request_id:
-                    request_id = raw_request_id
-                raw_command = preliminary.get("type")
-                if isinstance(raw_command, str):
-                    command = raw_command[:128]
-            request_id, command, payload = self._decode_message(raw)
-            if request_id in self._seen_request_ids:
-                raise ValueError(f"duplicate request_id: {request_id}")  # noqa: TRY301
-            self._seen_request_ids.add(request_id)
-            self._request_id_order.append(request_id)
-            if len(self._request_id_order) > 10_000:
-                self._seen_request_ids.discard(self._request_id_order.popleft())
-            if command == "collection.resync":
-                collection = payload.get("collection")
-                if not isinstance(collection, str) or collection not in _COLLECTIONS:
-                    choices = ", ".join(_COLLECTIONS)
-                    raise ValueError(f"collection must be one of: {choices}")  # noqa: TRY301
-                result: dict[str, Any] = {"collection": collection, "resyncing": True}
-                resync = collection
-            else:
-                result = await self.controller.handle(command, payload)
-            response = envelope(
-                "command_result",
-                {"ok": True, "command": command, "result": result},
-                request_id=request_id,
-            )
-        except Exception as exc:  # noqa: BLE001 - command failures are protocol results
-            if request_id is None:
-                # A malformed envelope without an ID cannot be correlated. Keep
-                # the reader alive and wait for the next valid command.
-                logger.warning("Ignoring uncorrelatable TUI command: %s", exc)
-                return None, None
-            response = envelope(
-                "command_result",
-                {
-                    "ok": False,
-                    "command": command,
-                    "error": self._structured_error(exc),
-                },
-                request_id=request_id,
-            )
-        return response, resync
-
-    def _encode(self, message: dict[str, Any]) -> bytes:
-        raw = json.dumps(
-            self._sanitize_wire_value(message),
-            default=str,
-            ensure_ascii=False,
-            separators=(",", ":"),
-        ).encode("utf-8")
-        maximum = (
-            MAX_COLLECTION_FRAME_BYTES
-            if message.get("type") in {"collection_bootstrap", "collection_delta"}
-            else MAX_COMMAND_BYTES
-        )
-        if len(raw) > maximum:
-            raise _MessageTooLargeError(f"TUI IPC message exceeds {maximum} bytes")
-        return raw
-
-    @classmethod
-    def _sanitize_wire_value(cls, value: Any) -> Any:
-        if isinstance(value, str):
-            return sanitize_terminal_text(value)
-        if isinstance(value, dict):
-            return {
-                sanitize_terminal_text(str(key)): cls._sanitize_wire_value(item)
-                for key, item in value.items()
-            }
-        if isinstance(value, list):
-            return [cls._sanitize_wire_value(item) for item in value]
-        if isinstance(value, tuple):
-            return [cls._sanitize_wire_value(item) for item in value]
-        return value
-
-    async def _send(self, message: dict[str, Any]) -> None:
-        connection = self._socket
-        if connection is None:
-            raise ConnectionError("TUI IPC connection is closed")
-        raw = self._encode(message)
-        framed = _HEADER.pack(len(raw)) + raw
-        async with self._write_lock:
-            await asyncio.get_running_loop().sock_sendall(connection, framed)
-
-    async def _send_command_response(self, response: dict[str, Any]) -> None:
-        try:
-            await self._send(response)
-        except _MessageTooLargeError:
-            request_id = response.get("request_id")
-            payload = response.get("payload")
-            command = payload.get("command", "") if isinstance(payload, dict) else ""
-            await self._send(
-                envelope(
-                    "command_result",
-                    {
-                        "ok": False,
-                        "command": command,
-                        "error": {
-                            "code": "result_too_large",
-                            "message": "Command result exceeds the terminal frame limit",
-                            "retryable": False,
-                        },
-                    },
-                    request_id=request_id if isinstance(request_id, str) else None,
-                )
-            )
-
-    @staticmethod
-    def _fingerprint(value: Any) -> str:
-        return json.dumps(value, default=str, sort_keys=True, separators=(",", ":"))
-
-    async def _send_state_if_changed(self) -> None:
-        state = self.controller.snapshot()
-        fingerprint = self._fingerprint(state)
-        if fingerprint == self._state_fingerprint:
-            return
-        revision = self._state_revision + 1
-        await self._send(envelope("state", {"revision": revision, "state": state}))
-        self._state_revision = revision
-        self._state_fingerprint = fingerprint
-
-    @staticmethod
-    def _collection_values(
-        items: list[dict[str, Any]],
-    ) -> tuple[list[str], dict[str, dict[str, Any]], dict[str, str]]:
-        order: list[str] = []
-        by_id: dict[str, dict[str, Any]] = {}
-        fingerprints: dict[str, str] = {}
-        for item in items:
-            item_id = item.get("id")
-            if not isinstance(item_id, str) or not item_id:
-                continue
-            order.append(item_id)
-            by_id[item_id] = item
-            fingerprints[item_id] = TuiBackendServer._fingerprint(item)
-        return order, by_id, fingerprints
-
-    async def _send_collection_frames(
-        self,
-        message_type: str,
-        fixed: dict[str, Any],
-        field_name: str,
-        values: list[dict[str, Any]],
-    ) -> None:
-        cursor = 0
-        if not values:
-            payload = {**fixed, "cursor": 0, "next_cursor": 0, "done": True, field_name: []}
-            await self._send(envelope(message_type, payload))
-            return
-
-        while cursor < len(values):
-            chunk: list[dict[str, Any]] = []
-            next_cursor = cursor
-            empty_payload = {
-                **fixed,
-                "cursor": cursor,
-                "next_cursor": cursor,
-                "done": False,
-                field_name: [],
-            }
-            estimated_size = len(
-                json.dumps(
-                    envelope(message_type, empty_payload),
-                    default=str,
-                    separators=(",", ":"),
-                ).encode("utf-8")
-            )
-            while next_cursor < len(values):
-                item = values[next_cursor]
-                item_size = len(
-                    json.dumps(item, default=str, separators=(",", ":")).encode("utf-8")
-                )
-                if estimated_size + item_size + 1 > _COLLECTION_PAYLOAD_TARGET and chunk:
-                    break
-                chunk.append(item)
-                estimated_size += item_size + 1
-                next_cursor += 1
-            payload = {
-                **fixed,
-                "cursor": cursor,
-                "next_cursor": next_cursor,
-                "done": next_cursor == len(values),
-                field_name: chunk,
-            }
-            await self._send(envelope(message_type, payload))
-            cursor = next_cursor
-
-    async def _send_collection_bootstrap(
-        self,
-        name: str,
-        items: list[dict[str, Any]] | None = None,
-    ) -> None:
-        state = self._collections[name]
-        source_cursor: int | None = None
-        if items is None:
-            source_cursor, projected = self.controller.collection_snapshot(name)
-        else:
-            projected = items
-        order, by_id, fingerprints = self._collection_values(projected)
-        revision = state.revision + 1
-        await self._send_collection_frames(
-            "collection_bootstrap",
-            {"collection": name, "revision": revision},
-            "items",
-            [by_id[item_id] for item_id in order],
-        )
-        state.revision = revision
-        state.bootstrapped = True
-        state.order = order
-        state.items = by_id
-        state.fingerprints = fingerprints
-        state.source_cursor = source_cursor
-
-    async def _send_collection_if_changed(self, name: str) -> None:
-        state = self._collections[name]
-        if name == "events" and state.bootstrapped and state.source_cursor is not None:
-            next_cursor, changed = self.controller.collection_changes(
-                name,
-                state.source_cursor,
-            )
-            if next_cursor == state.source_cursor:
-                return
-            operations: list[dict[str, Any]] = []
-            for item in changed:
-                item_id = item.get("id")
-                if not isinstance(item_id, str) or not item_id:
-                    continue
-                operations.append({"op": "upsert", "item": item})
-                if item_id not in state.items:
-                    state.order.append(item_id)
-                state.items[item_id] = item
-                state.fingerprints[item_id] = self._fingerprint(item)
-            limit = _COLLECTION_ITEM_LIMITS[name]
-            while len(state.order) > limit:
-                removed_id = state.order.pop(0)
-                state.items.pop(removed_id, None)
-                state.fingerprints.pop(removed_id, None)
-                operations.append({"op": "delete", "id": removed_id})
-            if operations:
-                revision = state.revision + 1
-                await self._send_collection_frames(
-                    "collection_delta",
-                    {
-                        "collection": name,
-                        "base_revision": state.revision,
-                        "revision": revision,
-                    },
-                    "operations",
-                    operations,
-                )
-                state.revision = revision
-            state.source_cursor = next_cursor
-            return
-        projected = self.controller.collection(name)
-        order, by_id, fingerprints = self._collection_values(projected)
-        if not state.bootstrapped:
-            await self._send_collection_bootstrap(
-                name,
-                None if name == "events" else projected,
-            )
-            return
-        if order == state.order and fingerprints == state.fingerprints:
-            return
-
-        retained = [item_id for item_id in state.order if item_id in by_id]
-        expected_order = retained + [item_id for item_id in order if item_id not in state.items]
-        if order != expected_order:
-            await self._send_collection_bootstrap(name, projected)
-            return
-
-        operations = [
-            {"op": "delete", "id": item_id} for item_id in state.order if item_id not in by_id
-        ] + [
-            {"op": "upsert", "item": by_id[item_id]}
-            for item_id in order
-            if fingerprints[item_id] != state.fingerprints.get(item_id)
-        ]
-        if not operations:
-            await self._send_collection_bootstrap(name, projected)
-            return
-
-        revision = state.revision + 1
-        await self._send_collection_frames(
-            "collection_delta",
-            {
-                "collection": name,
-                "base_revision": state.revision,
-                "revision": revision,
-            },
-            "operations",
-            operations,
-        )
-        state.revision = revision
-        state.order = order
-        state.items = by_id
-        state.fingerprints = fingerprints
-
-    async def _flush_updates(self) -> None:
-        async with self._sync_lock:
-            await self._send_state_if_changed()
-            for name in _COLLECTIONS:
-                await self._send_collection_if_changed(name)
-
-    async def _resync_collection(self, name: str) -> None:
-        async with self._sync_lock:
-            await self._send_collection_bootstrap(name)
-
-    async def _broadcast_loop(self) -> None:
-        try:
-            while True:
-                await self._broadcast_event.wait()
-                self._broadcast_event.clear()
-                await asyncio.sleep(0.05)
-                await self._flush_updates()
-        except asyncio.CancelledError:
-            raise
-        except (_MessageTooLargeError, ValueError):
-            logger.exception("TUI projection could not be framed")
-            self._close_socket()
-        except (ConnectionError, OSError):
-            self._close_socket()

strix/interface/tui/cmd/strix-tui/main.go

@@ -1,35 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/usestrix/strix/tui/internal/app"
-	"github.com/usestrix/strix/tui/internal/render"
-)
-
-func main() {
-	app.SetVersion(os.Getenv("STRIX_VERSION"))
-	render.DetectKittyGraphics()
-	client, err := app.ConnectFromEnvironment()
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "connect to Strix backend:", err)
-		os.Exit(1)
-	}
-	defer client.Close()
-	if err := client.Handshake(); err != nil {
-		fmt.Fprintln(os.Stderr, "negotiate Strix TUI protocol:", err)
-		os.Exit(1)
-	}
-	program := tea.NewProgram(app.New(client), tea.WithAltScreen(), tea.WithMouseCellMotion())
-	finalModel, err := program.Run()
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "run TUI:", err)
-		os.Exit(1)
-	}
-	if model, ok := finalModel.(interface{ FatalError() error }); ok && model.FatalError() != nil {
-		fmt.Fprintln(os.Stderr, "run TUI:", model.FatalError())
-		os.Exit(1)
-	}
-}

strix/interface/tui/go.mod

@@ -1,32 +0,0 @@
-module github.com/usestrix/strix/tui
-
-go 1.24.0
-
-require (
-	github.com/alecthomas/chroma/v2 v2.14.0
-	github.com/atotto/clipboard v0.1.4
-	github.com/charmbracelet/bubbles v0.21.0
-	github.com/charmbracelet/bubbletea v1.3.10
-	github.com/charmbracelet/lipgloss v1.1.0
-	github.com/charmbracelet/x/ansi v0.10.1
-	github.com/charmbracelet/x/term v0.2.1
-	github.com/muesli/termenv v0.16.0
-	golang.org/x/sys v0.36.0
-)
-
-require (
-	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
-	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
-	github.com/dlclark/regexp2 v1.11.0 // indirect
-	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
-	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-localereader v0.0.1 // indirect
-	github.com/mattn/go-runewidth v0.0.16 // indirect
-	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
-	github.com/muesli/cancelreader v0.2.2 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
-	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	golang.org/x/text v0.3.8 // indirect
-)

strix/interface/tui/go.sum

@@ -1,61 +0,0 @@
-github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ4pzQ=
-github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE=
-github.com/alecthomas/assert/v2 v2.7.0 h1:QtqSACNS3tF7oasA8CU6A6sXZSBDqnm7RfpLl9bZqbE=
-github.com/alecthomas/assert/v2 v2.7.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
-github.com/alecthomas/chroma/v2 v2.14.0 h1:R3+wzpnUArGcQz7fCETQBzO5n9IMNi13iIs46aU4V9E=
-github.com/alecthomas/chroma/v2 v2.14.0/go.mod h1:QolEbTfmUHIMVpBqxeDnNBj2uoeI4EbYP4i6n68SG4I=
-github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
-github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
-github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
-github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
-github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
-github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
-github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWpi6yML8=
-github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA=
-github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
-github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
-github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw=
-github.com/charmbracelet/bubbletea v1.3.10/go.mod h1:ORQfo0fk8U+po9VaNvnV95UPWA1BitP1E0N6xJPlHr4=
-github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs=
-github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk=
-github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
-github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
-github.com/charmbracelet/x/ansi v0.10.1 h1:rL3Koar5XvX0pHGfovN03f5cxLbCF2YvLeyz7D2jVDQ=
-github.com/charmbracelet/x/ansi v0.10.1/go.mod h1:3RQDQ6lDnROptfpWuUVIUG64bD2g2BgntdxH0Ya5TeE=
-github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd h1:vy0GVL4jeHEwG5YOXDmi86oYw2yuYUGqz6a8sLwg0X8=
-github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
-github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
-github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
-github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
-github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
-github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
-github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
-github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
-github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
-github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
-github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
-github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
-github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
-github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
-github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
-github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
-github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
-github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
-github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
-github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
-golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561 h1:MDc5xs78ZrZr3HMQugiXOAkSZtfTpbJLDr/lwfgO53E=
-golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
-golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
-golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
-golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=

strix/interface/tui/history.py

@@ -1,72 +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)
-    # Open read-only: the scan process may be actively writing this WAL database
-    # from another process (the local viewer tails it live), and a reader must
-    # never lock or mutate it. mode=ro (not immutable=1) still reads the latest
-    # committed WAL state; WAL permits concurrent readers alongside the writer.
-    conn: sqlite3.Connection | None = None
-    try:
-        conn = sqlite3.connect(
-            f"file:{agents_db}?mode=ro",
-            uri=True,
-            check_same_thread=False,
-        )
-        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 []
-    finally:
-        if conn is not None:
-            conn.close()
-
-    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/internal/app/agents.go

@@ -1,253 +0,0 @@
-package app
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/charmbracelet/lipgloss"
-	"github.com/usestrix/strix/tui/internal/protocol"
-	"github.com/usestrix/strix/tui/internal/render"
-)
-
-type agentTreeEntry struct {
-	index  int
-	depth  int
-	prefix string
-}
-
-// agentTreeEntries mirrors Textual Tree's depth-first ordering while retaining
-// each agent's snapshot index for event lookup and commands.
-func agentTreeEntries(agents []protocol.Agent, collapsed map[string]bool) []agentTreeEntry {
-	indexByID := make(map[string]int, len(agents))
-	for i, agent := range agents {
-		indexByID[agent.ID] = i
-	}
-	children := make(map[int][]int, len(agents))
-	var roots []int
-	for i, agent := range agents {
-		parentIndex := -1
-		if agent.ParentID != nil {
-			if candidate, ok := indexByID[*agent.ParentID]; ok && candidate != i {
-				parentIndex = candidate
-			}
-		}
-		if parentIndex < 0 {
-			roots = append(roots, i)
-		} else {
-			children[parentIndex] = append(children[parentIndex], i)
-		}
-	}
-
-	entries := make([]agentTreeEntry, 0, len(agents))
-	visited := make(map[int]bool, len(agents))
-	var hideDescendants func(int)
-	hideDescendants = func(index int) {
-		for _, child := range children[index] {
-			if visited[child] {
-				continue
-			}
-			visited[child] = true
-			hideDescendants(child)
-		}
-	}
-	var walk func(int, int, []bool, bool)
-	walk = func(index, depth int, continuations []bool, isLast bool) {
-		if visited[index] {
-			return
-		}
-		visited[index] = true
-		var prefix strings.Builder
-		if depth > 0 {
-			for _, continues := range continuations {
-				if continues {
-					prefix.WriteString("│  ")
-				} else {
-					prefix.WriteString("   ")
-				}
-			}
-			if isLast {
-				prefix.WriteString("└─ ")
-			} else {
-				prefix.WriteString("├─ ")
-			}
-		}
-		entries = append(entries, agentTreeEntry{index: index, depth: depth, prefix: prefix.String()})
-		if collapsed[agents[index].ID] {
-			hideDescendants(index)
-			return
-		}
-		nextContinuations := continuations
-		if depth > 0 {
-			nextContinuations = append(append([]bool(nil), continuations...), !isLast)
-		}
-		for i, child := range children[index] {
-			walk(child, depth+1, nextContinuations, i == len(children[index])-1)
-		}
-	}
-	for i, root := range roots {
-		walk(root, 0, nil, i == len(roots)-1)
-	}
-	// Malformed cycles have no root. Keep their nodes visible rather than losing
-	// them, treating the first unvisited node as another root.
-	for i := range agents {
-		if !visited[i] {
-			walk(i, 0, nil, true)
-		}
-	}
-	return entries
-}
-
-func hasAgentChildren(agentID string, agents []protocol.Agent) bool {
-	for _, agent := range agents {
-		if agent.ParentID != nil && *agent.ParentID == agentID {
-			return true
-		}
-	}
-	return false
-}
-
-func windowStart(offset, length, size int) int {
-	return min(max(0, offset), max(0, length-size))
-}
-
-func selectedAgentRow(entries []agentTreeEntry, selectedIndex int) int {
-	for row, entry := range entries {
-		if entry.index == selectedIndex {
-			return row
-		}
-	}
-	return 0
-}
-
-func selectedAgentIndex(agents []protocol.Agent, selectedID string) int {
-	if selectedID != "" {
-		for i, agent := range agents {
-			if agent.ID == selectedID {
-				return i
-			}
-		}
-	}
-	return 0
-}
-
-func (m Model) selectedAgentID() string {
-	if m.selectedAgent >= 0 && m.selectedAgent < len(m.snapshot.Agents) {
-		return m.snapshot.Agents[m.selectedAgent].ID
-	}
-	return ""
-}
-
-func (m Model) selectedAgentCanStop() bool {
-	if m.selectedAgent < 0 || m.selectedAgent >= len(m.snapshot.Agents) {
-		return false
-	}
-	switch m.snapshot.Agents[m.selectedAgent].Status {
-	case "running", "waiting", "budget_paused":
-		return true
-	default:
-		return false
-	}
-}
-
-func (m Model) agentsView(width, height int) string {
-	// The tree's root ("Agents") is hidden (show_root = False), so no header row
-	// is drawn — only the agent nodes.
-	var lines []string
-	statusIcons := map[string]string{"running": "⚪", "waiting": "⏸", "budget_paused": "⏸", "completed": "🟢", "failed": "🔴", "crashed": "🔴", "stopped": "■"}
-	entries := agentTreeEntries(m.snapshot.Agents, m.collapsedAgents)
-	start := windowStart(m.agentOffset, len(entries), height)
-	end := min(len(entries), start+height)
-	for _, entry := range entries[start:end] {
-		agent := m.snapshot.Agents[entry.index]
-		icon := statusIcons[agent.Status]
-		if icon == "" {
-			icon = "○"
-		}
-		vulnSuffix := ""
-		if count := m.agentVulnCount(agent.ID); count > 0 {
-			vulnSuffix = fmt.Sprintf(" (%d)", count)
-		}
-		// Only a node with children carries a toggle; a leaf renders none at all,
-		// so its icon sits where its parent's toggle would be.
-		disclosure := ""
-		if hasAgentChildren(agent.ID, m.snapshot.Agents) {
-			disclosure = "▼ "
-			if m.collapsedAgents[agent.ID] {
-				disclosure = "▶ "
-			}
-		}
-		label := disclosure + icon + " " + agent.Name + vulnSuffix
-		// The guides are dim and stay outside the cursor; the cursor is a filled
-		// block behind the label alone.
-		labelStyle := lipgloss.NewStyle().Foreground(treeLabel)
-		if entry.index == m.selectedAgent {
-			labelStyle = labelStyle.Foreground(treeCursorFg).Background(treeCursorBg).Bold(true)
-		}
-		room := max(1, width-lipgloss.Width(entry.prefix))
-		lines = append(lines,
-			lipgloss.NewStyle().Foreground(treeGuide).Render(entry.prefix)+
-				labelStyle.Render(truncate(label, room)))
-	}
-	return strings.Join(lines, "\n")
-}
-
-// agentVulnCount counts vulnerabilities attributed to an agent, matching the
-// " (N)" suffix _update_agent_node appends to each tree node.
-func (m Model) agentVulnCount(agentID string) int {
-	count := 0
-	for _, vuln := range m.snapshot.Vulnerabilities {
-		if render.StringValue(vuln["agent_id"]) == agentID {
-			count++
-		}
-	}
-	return count
-}
-
-func (m *Model) ensureAgentVisible() {
-	entries := agentTreeEntries(m.snapshot.Agents, m.collapsedAgents)
-	if len(entries) == 0 {
-		m.agentOffset = 0
-		return
-	}
-	_, _, agentHeight := m.sidebarHeights()
-	rows := max(1, agentHeight-4)
-	row := selectedAgentRow(entries, m.selectedAgent)
-	if row < m.agentOffset {
-		m.agentOffset = row
-	} else if row >= m.agentOffset+rows {
-		m.agentOffset = row - rows + 1
-	}
-	m.agentOffset = min(m.agentOffset, max(0, len(entries)-rows))
-}
-
-func (m Model) agentPageSize() int {
-	_, _, agentHeight := m.sidebarHeights()
-	return max(1, agentHeight-4)
-}
-
-func (m *Model) keepAgentSelectionInWindow() {
-	entries := agentTreeEntries(m.snapshot.Agents, m.collapsedAgents)
-	if len(entries) == 0 {
-		return
-	}
-	rows := m.agentPageSize()
-	row := selectedAgentRow(entries, m.selectedAgent)
-	if row < m.agentOffset {
-		m.selectedAgent = entries[m.agentOffset].index
-	} else if row >= m.agentOffset+rows {
-		m.selectedAgent = entries[min(len(entries)-1, m.agentOffset+rows-1)].index
-	}
-}
-
-func (m Model) agentHasEvents(agentID string) bool {
-	for _, event := range m.snapshot.Events {
-		if event.AgentID == agentID {
-			return true
-		}
-	}
-	return false
-}
-
-// sweepView ports _get_sweep_animation: a triangle-wave sweep of six squares
-// across an 8-color palette (dimmest shows a "·"), matching the Python cadence
-// and motion exactly.

strix/interface/tui/internal/app/client.go

@@ -1,250 +0,0 @@
-package app
-
-import (
-	"encoding/binary"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net"
-	"os"
-	"reflect"
-	"strconv"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/usestrix/strix/tui/internal/protocol"
-)
-
-const (
-	maxCommandBytes    = 64 << 10
-	maxCollectionBytes = 4 << 20
-)
-
-var ErrCommandPending = errors.New("command is already pending")
-
-type Client struct {
-	conn           io.ReadWriteCloser
-	mu             sync.Mutex
-	seq            atomic.Uint64
-	pending        map[string]string
-	pendingByKey   map[string]string
-	requestKeyByID map[string]string
-}
-
-// ConnectInherited opens the connected socket descriptor passed by the Python
-// parent. No listener, network address, or authentication secret is involved.
-func ConnectInherited(fdValue string) (*Client, error) {
-	fd, err := strconv.ParseUint(fdValue, 10, 64)
-	if err != nil {
-		return nil, fmt.Errorf("invalid STRIX_TUI_FD: %w", err)
-	}
-	file := os.NewFile(uintptr(fd), "strix-tui-ipc")
-	if file == nil {
-		return nil, fmt.Errorf("invalid STRIX_TUI_FD %d", fd)
-	}
-	connection, err := net.FileConn(file)
-	_ = file.Close()
-	if err != nil {
-		return nil, fmt.Errorf("open inherited TUI connection: %w", err)
-	}
-	return newClient(connection), nil
-}
-
-func newClient(connection io.ReadWriteCloser) *Client {
-	return &Client{
-		conn:           connection,
-		pending:        map[string]string{},
-		pendingByKey:   map[string]string{},
-		requestKeyByID: map[string]string{},
-	}
-}
-
-// ConnectFromEnvironment selects the private transport prepared by the Python
-// parent. POSIX uses an inherited descriptor; Windows uses an authenticated
-// one-use loopback connection because pass_fds is unavailable there.
-func ConnectFromEnvironment() (*Client, error) {
-	if fd := os.Getenv("STRIX_TUI_FD"); fd != "" {
-		_ = os.Unsetenv("STRIX_TUI_FD")
-		return ConnectInherited(fd)
-	}
-
-	address := os.Getenv("STRIX_TUI_ADDR")
-	token := os.Getenv("STRIX_TUI_TOKEN")
-	_ = os.Unsetenv("STRIX_TUI_ADDR")
-	_ = os.Unsetenv("STRIX_TUI_TOKEN")
-	if address == "" || token == "" {
-		return nil, fmt.Errorf("STRIX_TUI_FD or STRIX_TUI_ADDR and STRIX_TUI_TOKEN are required")
-	}
-
-	connection, err := net.DialTimeout("tcp", address, 10*time.Second)
-	if err != nil {
-		return nil, fmt.Errorf("connect to TUI backend: %w", err)
-	}
-	if err := writeAll(connection, []byte(token)); err != nil {
-		connection.Close()
-		return nil, fmt.Errorf("authenticate to TUI backend: %w", err)
-	}
-	return newClient(connection), nil
-}
-
-func writeAll(writer io.Writer, data []byte) error {
-	for len(data) > 0 {
-		n, err := writer.Write(data)
-		if err != nil {
-			return err
-		}
-		if n == 0 {
-			return io.ErrShortWrite
-		}
-		data = data[n:]
-	}
-	return nil
-}
-
-func (c *Client) readEnvelope(maximum uint32) (protocol.Envelope, int, error) {
-	var header [4]byte
-	if _, err := io.ReadFull(c.conn, header[:]); err != nil {
-		return protocol.Envelope{}, 0, err
-	}
-	size := binary.BigEndian.Uint32(header[:])
-	if size == 0 || size > maximum {
-		return protocol.Envelope{}, 0, fmt.Errorf("invalid TUI IPC message size: %d", size)
-	}
-	raw := make([]byte, size)
-	if _, err := io.ReadFull(c.conn, raw); err != nil {
-		return protocol.Envelope{}, 0, err
-	}
-	var envelope protocol.Envelope
-	if err := json.Unmarshal(raw, &envelope); err != nil {
-		return protocol.Envelope{}, 0, err
-	}
-	return envelope, int(size), nil
-}
-
-func (c *Client) Read() (protocol.Envelope, error) {
-	envelope, size, err := c.readEnvelope(maxCollectionBytes)
-	if err != nil {
-		return protocol.Envelope{}, err
-	}
-	if envelope.Type != "collection_bootstrap" && envelope.Type != "collection_delta" && size > maxCommandBytes {
-		return protocol.Envelope{}, fmt.Errorf("TUI control message exceeds %d bytes", maxCommandBytes)
-	}
-	return envelope, nil
-}
-
-// Handshake validates the exact v3 hello and acknowledges readiness. main calls
-// this before constructing Bubble Tea, so mismatch errors never enter alt screen.
-func (c *Client) Handshake() error {
-	if connection, ok := c.conn.(interface{ SetDeadline(time.Time) error }); ok {
-		if err := connection.SetDeadline(time.Now().Add(10 * time.Second)); err != nil {
-			return err
-		}
-		defer connection.SetDeadline(time.Time{}) //nolint:errcheck
-	}
-	envelope, _, err := c.readEnvelope(maxCommandBytes)
-	if err != nil {
-		return fmt.Errorf("read protocol hello: %w", err)
-	}
-	if envelope.Version != protocol.Version {
-		return fmt.Errorf("protocol mismatch: backend=%d client=%d", envelope.Version, protocol.Version)
-	}
-	if envelope.Type != "hello" {
-		return fmt.Errorf("protocol handshake expected hello, received %q", envelope.Type)
-	}
-	var hello protocol.Hello
-	if err := json.Unmarshal(envelope.Payload, &hello); err != nil {
-		return fmt.Errorf("decode protocol hello: %w", err)
-	}
-	if !reflect.DeepEqual(hello.Capabilities, protocol.Capabilities) {
-		return fmt.Errorf("protocol capability mismatch")
-	}
-	payload, err := json.Marshal(protocol.Hello{Capabilities: protocol.Capabilities})
-	if err != nil {
-		return err
-	}
-	return c.sendEnvelope(protocol.Envelope{
-		Version: protocol.Version,
-		Type:    "ready",
-		Payload: payload,
-	}, maxCommandBytes)
-}
-
-func (c *Client) sendEnvelope(envelope protocol.Envelope, maximum int) error {
-	raw, err := json.Marshal(envelope)
-	if err != nil {
-		return err
-	}
-	if len(raw) > maximum {
-		return fmt.Errorf("TUI IPC message exceeds %d bytes", maximum)
-	}
-	framed := make([]byte, 4+len(raw))
-	binary.BigEndian.PutUint32(framed[:4], uint32(len(raw)))
-	copy(framed[4:], raw)
-	return writeAll(c.conn, framed)
-}
-
-func pendingKey(command string, payload json.RawMessage) string {
-	if command == "collection.resync" {
-		return command + ":" + string(payload)
-	}
-	return command
-}
-
-func (c *Client) Send(command string, payload any) (string, error) {
-	rawPayload, err := json.Marshal(payload)
-	if err != nil {
-		return "", err
-	}
-	requestID := fmt.Sprintf("go-%d", c.seq.Add(1))
-	envelope := protocol.Envelope{
-		Version: protocol.Version, Type: command, RequestID: requestID, Payload: rawPayload,
-	}
-	key := pendingKey(command, rawPayload)
-
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	if c.pending == nil {
-		c.pending = map[string]string{}
-		c.pendingByKey = map[string]string{}
-		c.requestKeyByID = map[string]string{}
-	}
-	if existing := c.pendingByKey[key]; existing != "" {
-		return "", fmt.Errorf("%w: %s (%s)", ErrCommandPending, command, existing)
-	}
-	c.pending[requestID] = command
-	c.pendingByKey[key] = requestID
-	c.requestKeyByID[requestID] = key
-	if err := c.sendEnvelope(envelope, maxCommandBytes); err != nil {
-		delete(c.pending, requestID)
-		delete(c.pendingByKey, key)
-		delete(c.requestKeyByID, requestID)
-		return "", err
-	}
-	return requestID, nil
-}
-
-// Resolve accepts only the exact request/command pair that was submitted.
-// Unknown or mismatched results remain inert and do not release pending state.
-func (c *Client) Resolve(requestID, command string) bool {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	if requestID == "" || c.pending[requestID] != command {
-		return false
-	}
-	key := c.requestKeyByID[requestID]
-	delete(c.pending, requestID)
-	delete(c.pendingByKey, key)
-	delete(c.requestKeyByID, requestID)
-	return true
-}
-
-func (c *Client) ExpectedCommand(requestID string) (string, bool) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	command, ok := c.pending[requestID]
-	return command, ok
-}
-
-func (c *Client) Close() error { return c.conn.Close() }

strix/interface/tui/internal/app/client_test.go

@@ -1,284 +0,0 @@
-package app
-
-import (
-	"bytes"
-	"encoding/binary"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/usestrix/strix/tui/internal/protocol"
-)
-
-func writeEnvelopeFrame(writer io.Writer, envelope protocol.Envelope) error {
-	raw, err := json.Marshal(envelope)
-	if err != nil {
-		return err
-	}
-	var header [4]byte
-	binary.BigEndian.PutUint32(header[:], uint32(len(raw)))
-	return writeAll(writer, append(header[:], raw...))
-}
-
-func readEnvelopeFrame(reader io.Reader) (protocol.Envelope, error) {
-	var header [4]byte
-	if _, err := io.ReadFull(reader, header[:]); err != nil {
-		return protocol.Envelope{}, err
-	}
-	raw := make([]byte, binary.BigEndian.Uint32(header[:]))
-	if _, err := io.ReadFull(reader, raw); err != nil {
-		return protocol.Envelope{}, err
-	}
-	var envelope protocol.Envelope
-	return envelope, json.Unmarshal(raw, &envelope)
-}
-
-func TestHandshakeValidatesHelloAndSendsReady(t *testing.T) {
-	server, connection := net.Pipe()
-	client := newClient(connection)
-	serverErr := make(chan error, 1)
-	go func() {
-		defer server.Close()
-		payload, _ := json.Marshal(protocol.Hello{Capabilities: protocol.Capabilities})
-		if err := writeEnvelopeFrame(server, protocol.Envelope{Version: protocol.Version, Type: "hello", Payload: payload}); err != nil {
-			serverErr <- err
-			return
-		}
-		var header [4]byte
-		if _, err := io.ReadFull(server, header[:]); err != nil {
-			serverErr <- err
-			return
-		}
-		raw := make([]byte, binary.BigEndian.Uint32(header[:]))
-		if _, err := io.ReadFull(server, raw); err != nil {
-			serverErr <- err
-			return
-		}
-		var ready protocol.Envelope
-		if err := json.Unmarshal(raw, &ready); err != nil {
-			serverErr <- err
-			return
-		}
-		var readyPayload protocol.Hello
-		if err := json.Unmarshal(ready.Payload, &readyPayload); err != nil {
-			serverErr <- err
-			return
-		}
-		if ready.Type != "ready" || ready.Version != protocol.Version || !reflect.DeepEqual(readyPayload.Capabilities, protocol.Capabilities) {
-			serverErr <- fmt.Errorf("unexpected ready: %#v %#v", ready, readyPayload)
-			return
-		}
-		serverErr <- nil
-	}()
-
-	if err := client.Handshake(); err != nil {
-		t.Fatal(err)
-	}
-	if err := <-serverErr; err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestHandshakeRejectsMismatchBeforeReady(t *testing.T) {
-	server, connection := net.Pipe()
-	client := newClient(connection)
-	go func() {
-		defer server.Close()
-		payload, _ := json.Marshal(protocol.Hello{Capabilities: []string{"state-revisions"}})
-		_ = writeEnvelopeFrame(server, protocol.Envelope{Version: 2, Type: "hello", Payload: payload})
-	}()
-
-	err := client.Handshake()
-	if err == nil || !strings.Contains(err.Error(), "protocol mismatch") {
-		t.Fatalf("handshake error = %v, want protocol mismatch", err)
-	}
-}
-
-func TestReadRejectsOversizedCollectionLengthBeforePayload(t *testing.T) {
-	server, connection := net.Pipe()
-	client := newClient(connection)
-	written := make(chan error, 1)
-	go func() {
-		var header [4]byte
-		binary.BigEndian.PutUint32(header[:], maxCollectionBytes+1)
-		_, err := server.Write(header[:])
-		written <- err
-	}()
-
-	_, err := client.Read()
-	if err == nil || !strings.Contains(err.Error(), "invalid TUI IPC message size") {
-		t.Fatalf("read error = %v", err)
-	}
-	if err := <-written; err != nil {
-		t.Fatal(err)
-	}
-	server.Close()
-}
-
-func TestClientPreventsDuplicateCommandsAndRequiresExactCorrelation(t *testing.T) {
-	connection := &recordingConn{}
-	client := newClient(connection)
-	requestID, err := client.Send("setup.select_model", map[string]string{"model": "openai/gpt-5"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := client.Send("setup.select_model", map[string]string{"model": "openai/gpt-5.1"}); !errors.Is(err, ErrCommandPending) {
-		t.Fatalf("duplicate error = %v, want ErrCommandPending", err)
-	}
-	if client.Resolve("unknown", "setup.select_model") || client.Resolve(requestID, "models.list") {
-		t.Fatal("unknown or mismatched result resolved pending request")
-	}
-	if !client.Resolve(requestID, "setup.select_model") {
-		t.Fatal("exact result did not resolve pending request")
-	}
-	if _, err := client.Send("setup.select_model", map[string]string{"model": "openai/gpt-5.1"}); err != nil {
-		t.Fatalf("command remained blocked after success: %v", err)
-	}
-}
-
-func TestClientRejectsOversizedCommandBeforeWrite(t *testing.T) {
-	connection := &recordingConn{}
-	client := newClient(connection)
-	_, err := client.Send("setup.set_instruction", map[string]string{"instruction": strings.Repeat("x", maxCommandBytes)})
-	if err == nil || !strings.Contains(err.Error(), "exceeds") {
-		t.Fatalf("oversized send error = %v", err)
-	}
-	if connection.Len() != 0 || len(client.pending) != 0 {
-		t.Fatal("oversized command was written or left pending")
-	}
-}
-
-func TestClientReadsCollectionFrameLargerThanOneMegabyte(t *testing.T) {
-	server, connection := net.Pipe()
-	client := &Client{conn: connection}
-	payload, err := json.Marshal(map[string]string{"content": string(bytes.Repeat([]byte("x"), 2<<20))})
-	if err != nil {
-		t.Fatal(err)
-	}
-	raw, err := json.Marshal(protocol.Envelope{
-		Version: protocol.Version,
-		Type:    "collection_bootstrap",
-		Payload: payload,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	writeErr := make(chan error, 1)
-	go func() {
-		defer server.Close()
-		var header [4]byte
-		binary.BigEndian.PutUint32(header[:], uint32(len(raw)))
-		if _, err := server.Write(header[:]); err != nil {
-			writeErr <- err
-			return
-		}
-		_, err := server.Write(raw)
-		writeErr <- err
-	}()
-
-	message, err := client.Read()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if message.Type != "collection_bootstrap" {
-		t.Fatalf("message type = %q, want collection_bootstrap", message.Type)
-	}
-	if err := <-writeErr; err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestConnectFromEnvironmentAuthenticatesTCPTransport(t *testing.T) {
-	listener, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer listener.Close()
-
-	t.Setenv("STRIX_TUI_ADDR", listener.Addr().String())
-	t.Setenv("STRIX_TUI_TOKEN", "one-use-token")
-	t.Setenv("STRIX_TUI_FD", "")
-
-	serverErr := make(chan error, 1)
-	go func() {
-		connection, acceptErr := listener.Accept()
-		if acceptErr != nil {
-			serverErr <- acceptErr
-			return
-		}
-		defer connection.Close()
-		token := make([]byte, len("one-use-token"))
-		if _, readErr := io.ReadFull(connection, token); readErr != nil {
-			serverErr <- readErr
-			return
-		}
-		if string(token) != "one-use-token" {
-			serverErr <- os.ErrPermission
-			return
-		}
-		raw, marshalErr := json.Marshal(protocol.Envelope{
-			Version: protocol.Version,
-			Type:    "hello",
-			Payload: json.RawMessage(`{}`),
-		})
-		if marshalErr != nil {
-			serverErr <- marshalErr
-			return
-		}
-		var header [4]byte
-		binary.BigEndian.PutUint32(header[:], uint32(len(raw)))
-		if writeErr := writeAll(connection, append(header[:], raw...)); writeErr != nil {
-			serverErr <- writeErr
-			return
-		}
-		serverErr <- nil
-	}()
-
-	client, err := ConnectFromEnvironment()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer client.Close()
-	message, err := client.Read()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if message.Type != "hello" {
-		t.Fatalf("message type = %q, want hello", message.Type)
-	}
-	if err := <-serverErr; err != nil {
-		t.Fatal(err)
-	}
-	if os.Getenv("STRIX_TUI_ADDR") != "" || os.Getenv("STRIX_TUI_TOKEN") != "" {
-		t.Fatal("TCP transport credentials were not removed from the environment")
-	}
-}
-
-func TestConnectFromEnvironmentRequiresCompleteTransport(t *testing.T) {
-	t.Setenv("STRIX_TUI_FD", "")
-	t.Setenv("STRIX_TUI_ADDR", "127.0.0.1:1")
-	t.Setenv("STRIX_TUI_TOKEN", "")
-
-	_, err := ConnectFromEnvironment()
-	if err == nil || !strings.Contains(err.Error(), "STRIX_TUI_ADDR and STRIX_TUI_TOKEN") {
-		t.Fatalf("error = %v, want missing transport error", err)
-	}
-}
-
-func TestConnectFromEnvironmentPrefersInheritedDescriptor(t *testing.T) {
-	t.Setenv("STRIX_TUI_FD", "not-a-number")
-	t.Setenv("STRIX_TUI_ADDR", "127.0.0.1:1")
-	t.Setenv("STRIX_TUI_TOKEN", "token")
-
-	_, err := ConnectFromEnvironment()
-	if err == nil || !strings.Contains(err.Error(), "invalid STRIX_TUI_FD") {
-		t.Fatalf("error = %v, want inherited descriptor parse error", err)
-	}
-}