chore: drop added comments and docstrings

Co-authored-by: Ahmed Allam <ahmed39652003@gmail.com>

.github/workflows/build-release.yml

@@ -6,6 +6,9 @@ on:
       - 'v*'
   workflow_dispatch:
 
+permissions:
+  contents: read
+
 jobs:
   build:
     strategy:
@@ -24,13 +27,15 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262  # v4.4.0
+        with:
+          persist-credentials: false
 
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065  # v5.6.0
         with:
           python-version: '3.12'
 
-      - uses: astral-sh/setup-uv@v5
+      - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86  # v5.4.2
 
       - name: Build
         shell: bash
@@ -50,7 +55,7 @@ jobs:
             tar -C dist/release -czvf "dist/release/strix-${VERSION}-${{ matrix.target }}.tar.gz" "strix-${VERSION}-${{ matrix.target }}"
           fi
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02  # v4.6.2
         with:
           name: strix-${{ matrix.target }}
           path: |
@@ -65,13 +70,13 @@ jobs:
       contents: write
 
     steps:
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093  # v4.3.0
         with:
           path: release
           merge-multiple: true
 
       - name: Create Release
-        uses: softprops/action-gh-release@v2
+        uses: softprops/action-gh-release@3bb12739c298aeb8a4eeaf626c5b8d85266b0e65  # v2.6.2
         with:
           prerelease: ${{ !startsWith(github.ref, 'refs/tags/') }}
           generate_release_notes: true

.gitignore

@@ -1,8 +1,8 @@
 # Node / local-viewer SPA source (the built bundle in
-# strix/viewer/static/ is committed and shipped; do not ignore it)
+# strix/interface/viewer/static/ is committed and shipped; do not ignore it)
 node_modules/
-strix/viewer/frontend/node_modules/
-strix/viewer/frontend/.vite/
+strix/interface/viewer/frontend/node_modules/
+strix/interface/viewer/frontend/.vite/
 
 # Python
 __pycache__/

CONTRIBUTING.md

@@ -102,16 +102,16 @@ We welcome feature ideas! Please:
 ## 🖥️ Local viewer SPA
 
 `strix view` serves a prebuilt web UI whose source lives in
-`strix/viewer/frontend/` (a Vite + React project) and whose built output is
-committed to `strix/viewer/static/` and shipped in the package. End users never
-run a JS build. If you change anything under `strix/viewer/frontend/`, rebuild
+`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/viewer/frontend && npm ci && npm run build
+make viewer   # or: cd strix/interface/viewer/frontend && npm ci && npm run build
 ```
 
-Commit both the source change and the regenerated `strix/viewer/static/`.
+Commit both the source change and the regenerated `strix/interface/viewer/static/`.
 
 ## 🤝 Community
 

Makefile

@@ -69,8 +69,8 @@ clean:
 
 viewer:
 	@echo "🖥️  Building the local-viewer SPA..."
-	cd strix/viewer/frontend && npm ci && npm run build
-	@echo "✅ Viewer built to strix/viewer/static/ (commit the changes)."
+	cd strix/interface/viewer/frontend && npm ci && npm run build
+	@echo "✅ Viewer built to strix/interface/viewer/static/ (commit the changes)."
 
 dev: format lint type-check
 	@echo "✅ Development cycle complete!"

README.md

@@ -267,6 +267,20 @@ 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`

docs/advanced/configuration.mdx

@@ -35,6 +35,31 @@ Configure Strix using environment variables or a config file.
   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="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">

docs/usage/cli.mdx

@@ -116,5 +116,6 @@ strix --mount ./huge-monorepo
 
 | Code | Meaning |
 |------|---------|
-| 0 | Scan completed, no vulnerabilities found |
+| 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) |
 | 2 | Vulnerabilities found (headless mode only) |

pyproject.toml

@@ -46,7 +46,9 @@ dependencies = [
   "caido-sdk-client>=0.2.0",
   "reportlab>=4.0",
   "pypdf>=5.0",
-  "cryptography>=48.0.1",
+  # 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",
 ]
 
 [project.optional-dependencies]
@@ -77,10 +79,10 @@ build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
 packages = ["strix"]
-# The prebuilt viewer bundle under strix/viewer/static/ ships automatically
+# 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/viewer/frontend/) but must never ship in the wheel.
-exclude = ["strix/viewer/frontend", "strix/viewer/frontend/**"]
+# 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/**"]
 
 # ============================================================================
 # Type Checking Configuration
@@ -120,6 +122,7 @@ module = [
     "pydantic_settings.*",
     "reportlab.*",
     "pypdf.*",
+    "pygments.*",
 ]
 ignore_missing_imports = true
 disable_error_code = ["import-untyped"]
@@ -213,12 +216,16 @@ ignore = [
 # 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"]
+# Stdlib HTTP handler overrides (do_GET/do_POST).
+"strix/interface/auth_cli.py" = ["N802"]
+"tests/test_codex_streaming.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.viewer.report_pdf.
-"strix/viewer/server.py" = ["N802", "PLC0415"]
+# 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/viewer/cli.py" = ["PLC0415"]
+"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"]
@@ -251,9 +258,16 @@ ignore = [
 "strix/core/runner.py" = ["TC003", "PLR0912", "PLR0915", "PLC0415"]
 # ReportState carries scan artifact/report fields and
 # a runtime ``Callable`` annotation on ``vulnerability_found_callback``.
-"strix/report/state.py" = ["TC003", "PLR0912", "PLR0915", "E501", "PERF401"]
+"strix/report/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"]

strix.spec

@@ -26,7 +26,7 @@ for tcss_file in strix_root.rglob('*.tcss'):
     datas.append((str(tcss_file), str(rel_path.parent)))
 
 # Prebuilt local-viewer SPA (served by `strix view`).
-viewer_static = strix_root / 'viewer' / 'static'
+viewer_static = strix_root / 'interface' / 'viewer' / 'static'
 for asset in viewer_static.rglob('*'):
     if asset.is_file():
         rel_path = asset.relative_to(project_root)
@@ -158,12 +158,12 @@ hiddenimports = [
     'strix.report.dedupe',
     'strix.report.state',
     'strix.report.writer',
-    'strix.viewer',
-    'strix.viewer.auth',
-    'strix.viewer.cli',
-    'strix.viewer.report_pdf',
-    'strix.viewer.server',
-    'strix.viewer.transcript',
+    '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',

strix/agents/factory.py

@@ -16,6 +16,7 @@ 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,
@@ -33,6 +34,7 @@ from strix.tools.notes.tools import (
     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,
@@ -41,7 +43,12 @@ from strix.tools.proxy.tools import (
     view_request,
     view_sitemap_entry,
 )
-from strix.tools.reporting.tool import create_dependency_report, create_vulnerability_report
+from strix.tools.reporting.tool import (
+    create_dependency_report,
+    create_vulnerability_report,
+    get_report,
+    list_reports,
+)
 from strix.tools.thinking.tool import think
 from strix.tools.todo.tools import (
     create_todo,
@@ -103,8 +110,36 @@ def _extract_custom_input(tool: CustomTool, raw_input: str | dict[str, Any]) ->
     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:
-    return str(exc) or exc.__class__.__name__
+    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 _function_tool_with_error_result(tool: FunctionTool) -> FunctionTool:
@@ -112,7 +147,7 @@ def _function_tool_with_error_result(tool: FunctionTool) -> FunctionTool:
 
     async def invoke(ctx: Any, raw_input: str) -> Any:
         try:
-            return await invoke_tool(ctx, raw_input)
+            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)
@@ -127,7 +162,7 @@ def _custom_tool_as_function_tool(tool: CustomTool) -> FunctionTool:
         if not custom_input:
             return f"`{_custom_tool_input_field(tool)}` must be a non-empty string."
         try:
-            return await tool.on_invoke_tool(ctx, custom_input)
+            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)
@@ -159,12 +194,35 @@ def _custom_tool_as_function_tool(tool: CustomTool) -> FunctionTool:
     )
 
 
-def _configure_chat_completions_filesystem_tools(toolset: Any) -> None:
+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 isinstance(tool, CustomTool):
-            setattr(toolset, name, _custom_tool_as_function_tool(tool))
+        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(tool))
+        elif isinstance(tool, CustomTool):
+            setattr(toolset, name, _bound_custom_tool(tool))
         elif isinstance(tool, FunctionTool):
-            setattr(toolset, name, _function_tool_with_error_result(tool))
+            setattr(toolset, name, _with_bounded_result(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\\])")
@@ -205,6 +263,16 @@ def _format_validation_error(tool_name: str, exc: ValidationError) -> str:
     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
 
@@ -213,8 +281,10 @@ def _wrap_exec_command(tool: FunctionTool) -> FunctionTool:
             parsed = json.loads(raw_input)
         except (json.JSONDecodeError, TypeError):
             parsed = None
-        if isinstance(parsed, dict) and "shell" not in parsed:
-            parsed["shell"] = "bash"
+        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)
@@ -240,8 +310,10 @@ def _wrap_write_stdin(tool: FunctionTool) -> FunctionTool:
             parsed = json.loads(raw_input)
         except json.JSONDecodeError:
             parsed = None
-        if isinstance(parsed, dict) and isinstance(parsed.get("chars"), str):
-            parsed["chars"] = _decode_chars_escape(parsed["chars"])
+        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)
@@ -343,6 +415,8 @@ _BASE_TOOLS: tuple[Tool, ...] = (
     web_search,
     create_vulnerability_report,
     create_dependency_report,
+    list_reports,
+    get_report,
     list_requests,
     view_request,
     repeat_request,
@@ -440,6 +514,9 @@ def build_strix_agent(
     else:
         tools = [*_BASE_TOOLS, *agent_tools, agent_finish]
     _ensure_unique_tool_names(tools)
+    tools = [
+        _with_bounded_result(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)",
@@ -459,8 +536,8 @@ def build_strix_agent(
         model=None,
         capabilities=[
             Filesystem(
-                configure_tools=(
-                    _configure_chat_completions_filesystem_tools if chat_completions_tools else None
+                configure_tools=_make_filesystem_configurator(
+                    chat_completions=chat_completions_tools,
                 ),
             ),
             Shell(

strix/agents/prompts/system_prompt.jinja

@@ -188,7 +188,7 @@ EFFICIENCY TACTICS:
   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`, `msfconsole`, or to send Ctrl-C —
+  `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
@@ -215,6 +215,7 @@ VALIDATION REQUIREMENTS:
 - 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.)
 - 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>

strix/config/__init__.py

@@ -17,6 +17,8 @@ from strix.config.loader import (
     persist_current,
 )
 from strix.config.settings import (
+    ContextSettings,
+    DedupeSettings,
     IntegrationSettings,
     LlmSettings,
     RuntimeSettings,
@@ -26,6 +28,8 @@ from strix.config.settings import (
 
 
 __all__ = [
+    "ContextSettings",
+    "DedupeSettings",
     "IntegrationSettings",
     "LlmSettings",
     "RuntimeSettings",

strix/config/codex.py

@@ -0,0 +1,411 @@
+"""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.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+
+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:
+    AUTH_PATH.parent.mkdir(parents=True, exist_ok=True)
+    tmp = AUTH_PATH.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    with contextlib.suppress(OSError):
+        tmp.chmod(0o600)
+    tmp.replace(AUTH_PATH)
+    with contextlib.suppress(OSError):
+        AUTH_PATH.chmod(0o600)
+
+
+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]:
+    body = urllib.parse.urlencode(payload).encode("ascii")
+    request = urllib.request.Request(  # noqa: S310 - fixed https OAuth endpoint
+        TOKEN_URL,
+        data=body,
+        headers={
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept": "application/json",
+        },
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(  # noqa: S310  # nosec B310 - fixed https endpoint
+            request, timeout=_TOKEN_TIMEOUT
+        ) as response:
+            data = json.loads(response.read() or b"{}")
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode("utf-8", "replace")[:300]
+        raise CodexAuthError("token_http_error", f"HTTP {exc.code}: {detail}") from exc
+    except (urllib.error.URLError, TimeoutError, OSError) as exc:
+        raise CodexAuthError("unavailable", str(exc)) from exc
+    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/models.py

@@ -2,23 +2,38 @@
 
 from __future__ import annotations
 
+import contextlib
+import inspect
 import os
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
-from agents import set_default_openai_api, set_default_openai_key, set_tracing_disabled
+from agents import (
+    set_default_openai_api,
+    set_default_openai_key,
+    set_tracing_disabled,
+)
+from agents.model_settings import ModelSettings
 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.shared import Reasoning
+
+from strix.config import codex
+from strix.config.loader import load_settings
 
 
 if TYPE_CHECKING:
-    from agents.models.interface import ModelProvider
+    from collections.abc import AsyncIterator
 
-    from strix.config.settings import Settings
+    from agents.models.interface import Model, ModelProvider
+    from openai import AsyncOpenAI
+
+    from strix.config.settings import ReasoningEffort, Settings
 
 
 def request_timeout_extra_args(timeout_s: float | None) -> dict[str, float] | None:
@@ -33,9 +48,93 @@ def _retry_statusless_provider_errors(context: RetryPolicyContext) -> bool:
     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.
+            if effort == "minimal":
+                effort = "low"
+            elif effort == "xhigh":
+                effort = "high"
+            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 StrixProvider(MultiProvider):
     """Route any non-OpenAI prefix through LiteLLM with the prefix preserved,
     so users type ``deepseek/deepseek-chat`` rather than
@@ -59,6 +158,16 @@ class StrixProvider(MultiProvider):
             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:
+        slug = codex.subscription_model(model_name)
+        if slug:
+            return _CodexResponsesModel(
+                slug,
+                codex.get_subscription_client(),
+                reasoning_effort=load_settings().llm.reasoning_effort,
+            )
+        return super().get_model(model_name)
+
 
 DEFAULT_MODEL_RETRY = ModelRetrySettings(
     max_retries=5,
@@ -77,39 +186,42 @@ DEFAULT_MODEL_RETRY = ModelRetrySettings(
 )
 
 RECOMMENDED_MODEL_NAMES = (
-    "openai/gpt-5.6",
     "openai/gpt-5.6-sol",
     "openai/gpt-5.6-terra",
-    "openai/gpt-5.5",
+    "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-opus-4-7",
     "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",
-    "moonshot/kimi-k2.6",
 )
 
 _RECOMMENDED_MODEL_NAME_SET = frozenset(name.lower() for name in RECOMMENDED_MODEL_NAMES)
 
 FRONTIER_MODEL_FAMILIES = (
-    (("azure", "azure_ai", "bedrock_mantle", "openai"), ("gpt-5",)),
+    (("azure", "azure_ai", "bedrock_mantle", "chatgpt", "openai"), ("gpt-5",)),
     (
         ("anthropic", "azure_ai", "bedrock", "claude", "databricks", "snowflake", "vertex_ai"),
-        ("claude-fable-5", "claude-opus-4", "claude-sonnet-5", "claude-sonnet-4"),
+        ("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.7", "qwen3.5", "qwen3-max")),
-    (("moonshot", "moonshotai", "kimi"), ("kimi-k2.7", "kimi-k2.6", "kimi-k2.5")),
+    (("alibaba", "dashscope", "qwen"), ("qwen3.8", "qwen3.7", "qwen3-max")),
+    (("moonshot", "moonshotai", "kimi"), ("kimi-k3", "kimi-k2.7", "kimi-k2.6")),
 )
 
 
@@ -117,6 +229,8 @@ 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:
@@ -211,6 +325,8 @@ def _configure_litellm_default(name: str, value: str) -> None:
 
 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

strix/config/settings.py

@@ -43,6 +43,38 @@ class LlmSettings(BaseSettings):
     timeout: int = Field(default=300, alias="LLM_TIMEOUT")
 
 
+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")
+    api_base: str | None = Field(default=None, alias="DEDUPE_LLM_API_BASE")
+
+
+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
 
@@ -85,7 +117,9 @@ 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/core/agents.py

@@ -41,6 +41,7 @@ class AgentCoordinator:
         self.names: dict[str, str] = {}
         self.metadata: dict[str, dict[str, Any]] = {}
         self.pending_counts: dict[str, int] = {}
+        self.errors: dict[str, str] = {}
         self.runtimes: dict[str, AgentRuntime] = {}
         self._lock = asyncio.Lock()
         self._snapshot_path: Path | None = None
@@ -107,16 +108,23 @@ class AgentCoordinator:
         async with self._lock:
             if agent_id in self.statuses:
                 self.statuses[agent_id] = "running"
+                self.errors.pop(agent_id, None)
         await self._maybe_snapshot()
 
     async def park_waiting(self, agent_id: str) -> None:
         await self.set_status(agent_id, "waiting")
 
-    async def set_status(self, agent_id: str, status: Status | str) -> None:
+    async 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)
             runtime = self.runtimes.setdefault(agent_id, AgentRuntime())
             runtime.wake.set()
         logger.info("agent.status %s=%s", agent_id, status)
@@ -246,9 +254,14 @@ class AgentCoordinator:
 
     async def graph_snapshot(
         self,
-    ) -> tuple[dict[str, str | None], dict[str, Status], dict[str, str]]:
+    ) -> 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)
+            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"))
@@ -286,6 +299,7 @@ class AgentCoordinator:
                 "names": dict(self.names),
                 "metadata": {aid: dict(md) for aid, md in self.metadata.items()},
                 "pending_counts": dict(self.pending_counts),
+                "errors": dict(self.errors),
             }
 
     async def restore(self, snap: dict[str, Any]) -> None:
@@ -295,6 +309,7 @@ class AgentCoordinator:
             self.names = dict(snap.get("names", {}))
             self.metadata = {aid: dict(md) for aid, md in snap.get("metadata", {}).items()}
             self.pending_counts = dict(snap.get("pending_counts", {}))
+            self.errors = dict(snap.get("errors", {}))
             for aid in self.statuses:
                 self.runtimes.setdefault(aid, AgentRuntime())
 

strix/core/execution.py

@@ -13,7 +13,13 @@ from agents import RunConfig, Runner
 from agents.exceptions import AgentsException, MaxTurnsExceeded, UserError
 from agents.sandbox.errors import ExecTransportError
 from docker import errors as docker_errors  # type: ignore[import-untyped, unused-ignore]
-from openai import APIError
+from openai import (
+    APIConnectionError,
+    APIError,
+    APIStatusError,
+    APITimeoutError,
+    RateLimitError,
+)
 
 from strix.core.hooks import BudgetExceededError
 from strix.core.inputs import child_initial_input
@@ -22,6 +28,7 @@ from strix.core.sessions import (
     open_agent_session,
     strip_all_images_from_session,
 )
+from strix.llm.compaction import is_context_overflow, maybe_compact
 
 
 if TYPE_CHECKING:
@@ -40,6 +47,69 @@ logger = logging.getLogger(__name__)
 StreamEventSink = Callable[[str, Any], None]
 
 _INPUT_REJECTION_CODES = frozenset({400, 404, 422})
+_MAX_COMPACTIONS_PER_CYCLE = 2
+
+
+def _run_config_model(run_config: RunConfig) -> str | None:
+    return run_config.model if isinstance(run_config.model, str) else None
+
+
+def _agent_instructions(agent: Any) -> str:
+    instructions = getattr(agent, "instructions", None)
+    return instructions if isinstance(instructions, str) else ""
+
+
+def _agent_tools_text(agent: Any) -> str:
+    parts: list[str] = []
+    for tool in getattr(agent, "tools", []) or []:
+        name = getattr(tool, "name", "")
+        description = getattr(tool, "description", "") or ""
+        schema = getattr(tool, "params_json_schema", "") or ""
+        parts.append(f"{name} {description} {schema}")
+    return "\n".join(parts)
+
+
+async def _compact_session(
+    agent: Any, session: Session, run_config: RunConfig, *, force: bool
+) -> bool:
+    model = _run_config_model(run_config)
+    if session is None or model is None:
+        return False
+    return await maybe_compact(
+        session,
+        model=model,
+        instructions=_agent_instructions(agent),
+        tools_text=_agent_tools_text(agent),
+        force=force,
+    )
+
+
+_TRANSIENT_MODEL_STATUS_CODES = frozenset({408, 500, 502, 503, 504})
+_MAX_TRANSIENT_MODEL_RETRIES = 4
+_TRANSIENT_MODEL_RETRY_BASE_DELAY_S = 2.0
+_TRANSIENT_MODEL_RETRY_MAX_DELAY_S = 30.0
+
+
+def _model_error_status_code(exc: BaseException) -> int | None:
+    code = getattr(exc, "status_code", None)
+    return code if isinstance(code, int) else None
+
+
+def _is_transient_model_error(exc: BaseException) -> bool:
+    if isinstance(exc, RateLimitError):
+        return False
+    if isinstance(exc, APITimeoutError | APIConnectionError):
+        return True
+    if isinstance(exc, APIStatusError):
+        return exc.status_code in _TRANSIENT_MODEL_STATUS_CODES
+    if isinstance(exc, APIError):
+        return _model_error_status_code(exc) is None
+    return False
+
+
+def _transient_model_retry_delay(attempt: int) -> float:
+    delay = _TRANSIENT_MODEL_RETRY_BASE_DELAY_S * float(2 ** (attempt - 1))
+    return min(delay, _TRANSIENT_MODEL_RETRY_MAX_DELAY_S)
 
 
 async def run_agent_loop(
@@ -350,6 +420,8 @@ async def _run_cycle(  # noqa: PLR0912, PLR0915
     hooks: RunHooks[dict[str, Any]] | None,
 ) -> RunResultBase | None:
     image_strips = 0
+    compactions = 0
+    model_retries = 0
     while True:
         try:
             await coordinator.mark_running(agent_id)
@@ -360,6 +432,10 @@ async def _run_cycle(  # noqa: PLR0912, PLR0915
                         await enforce_image_budget(session, max_images)
                     except Exception:
                         logger.exception("image-budget enforcement failed for %s", agent_id)
+                try:
+                    await _compact_session(agent, session, run_config, force=False)
+                except Exception:
+                    logger.exception("proactive compaction failed for %s", agent_id)
             stream = Runner.run_streamed(
                 agent,
                 input=input_data,
@@ -428,6 +504,41 @@ async def _run_cycle(  # noqa: PLR0912, PLR0915
                     )
                     input_data = []
                     continue
+            if (
+                compactions < _MAX_COMPACTIONS_PER_CYCLE
+                and session is not None
+                and is_context_overflow(exc)
+            ):
+                try:
+                    compacted = await _compact_session(agent, session, run_config, force=True)
+                except Exception:
+                    logger.exception("overflow compaction recovery failed for %s", agent_id)
+                    compacted = False
+                if compacted:
+                    compactions += 1
+                    logger.info(
+                        "Compacted %s session after context overflow; retrying (%d)",
+                        agent_id,
+                        compactions,
+                    )
+                    input_data = []
+                    continue
+            if model_retries < _MAX_TRANSIENT_MODEL_RETRIES and _is_transient_model_error(exc):
+                model_retries += 1
+                delay = _transient_model_retry_delay(model_retries)
+                logger.warning(
+                    "transient model/provider error for %s; replaying turn "
+                    "(attempt %d/%d, backoff %.1fs): %r",
+                    agent_id,
+                    model_retries,
+                    _MAX_TRANSIENT_MODEL_RETRIES,
+                    delay,
+                    exc,
+                )
+                await asyncio.sleep(delay)
+                if session is not None:
+                    input_data = []
+                continue
             if not interactive:
                 raise
             if isinstance(exc, MaxTurnsExceeded):
@@ -437,10 +548,8 @@ async def _run_cycle(  # noqa: PLR0912, PLR0915
             else:
                 status = "crashed"
             logger.exception("agent run failed for %s; parking as %s", agent_id, status)
-            await coordinator.set_status(agent_id, status)
+            await coordinator.set_status(agent_id, status, error=str(exc) or type(exc).__name__)
             await _notify_parent_on_crash(coordinator, agent_id, status)
-            if context.get("parent_id") is None and status in {"failed", "crashed"}:
-                raise
             return None
         else:
             await _settle_run_result(coordinator, agent_id, interactive)

strix/core/runner.py

@@ -3,10 +3,12 @@
 from __future__ import annotations
 
 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
@@ -40,6 +42,10 @@ from strix.core.paths import run_dir_for, runtime_state_dir
 from strix.core.sessions import open_agent_session
 from strix.runtime import session_manager
 from strix.telemetry.logging import set_scan_id, setup_scan_logging
+from strix.tools.output_store import (
+    WORKSPACE_SPILL_DIR,
+    configure_spill_writer,
+)
 
 
 if TYPE_CHECKING:
@@ -203,6 +209,20 @@ async def run_strix_scan(
     )
     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:
@@ -238,7 +258,7 @@ async def run_strix_scan(
         )
 
         root_agent = build_strix_agent(
-            name="strix",
+            name="Strix",
             skills=skills,
             is_root=True,
             scan_mode=scan_mode,
@@ -252,7 +272,7 @@ async def run_strix_scan(
         if not is_resume:
             await coordinator.register(
                 root_id,
-                "strix",
+                "Strix",
                 parent_id=None,
                 task=root_task,
                 skills=skills,
@@ -399,6 +419,7 @@ async def run_strix_scan(
                 await coordinator.set_status(root_id, "failed")
         raise
     finally:
+        configure_spill_writer(None)
         for s in sessions_to_close:
             with contextlib.suppress(Exception):
                 s.close()

strix/core/sessions.py

@@ -92,6 +92,39 @@ async def _rewrite_session(
         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)."""
 

strix/interface/auth_cli.py

@@ -0,0 +1,419 @@
+"""`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/main.py

@@ -8,7 +8,6 @@ import asyncio
 import os
 import shutil
 import sys
-import time
 from datetime import UTC, datetime
 from pathlib import Path
 
@@ -21,6 +20,7 @@ from rich.text import Text
 
 from strix.config import (
     apply_config_override,
+    codex,
     load_settings,
     persist_current,
 )
@@ -93,6 +93,16 @@ def validate_environment() -> None:
 
     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")
 
@@ -275,6 +285,29 @@ def _provider_import_hint(exc: BaseException, model: str) -> str | None:
     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)."
+        )
+    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"
+        )
+    return None
+
+
 async def warm_up_llm(show_model_warning: bool = True) -> None:
     console = Console()
     logger.info("Warming up LLM connection")
@@ -284,8 +317,8 @@ async def warm_up_llm(show_model_warning: bool = True) -> None:
         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
@@ -361,23 +394,63 @@ async def warm_up_llm(show_model_warning: bool = True) -> None:
         )
         logger.info("LLM warm-up succeeded for model %s", (llm.model or "").strip())
 
+        if settings.dedupe.model:
+            from strix.report.dedupe import _dedupe_extra_args
+
+            dedupe_model = settings.dedupe.model.strip()
+            raw_model = dedupe_model
+            deduper = StrixProvider().get_model(dedupe_model)
+            # Match the runtime path: send the dedupe key/endpoint per call so a
+            # separate-provider dedupe model authenticates during warm-up too.
+            deduper_extra = _dedupe_extra_args(settings.dedupe)
+            deduper_settings = ModelSettings(extra_args=deduper_extra or None)
+            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 Exception as e:
         logger.exception("LLM warm-up failed")
         error_text = Text()
-        error_text.append("LLM CONNECTION FAILED", style="bold red")
-        error_text.append("\n\n", style="white")
-        error_text.append("Could not establish connection to the language model.\n", style="white")
-        error_text.append("Please check your configuration and try again.\n", style="white")
-        hint = _provider_import_hint(e, raw_model)
-        if hint is not None:
-            error_text.append(f"\n{hint}\n", style="bold yellow")
-        error_text.append(f"\nError: {e}", style="dim white")
+        sub_hint = _subscription_error_hint(e)
+        if sub_hint is not None:
+            # The model/backend answered with a clear, actionable rejection —
+            # show that instead of a generic "connection failed".
+            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: {e}", 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(e, raw_model)
+            if hint is not None:
+                error_text.append(f"\n{hint}\n", style="bold yellow")
+            error_text.append(f"\nError: {e}", style="dim white")
 
         panel = Panel(
             error_text,
             title="[bold white]STRIX",
             title_align="left",
-            border_style="red",
+            border_style=border_style,
             padding=(1, 2),
         )
 
@@ -683,6 +756,7 @@ def _persist_run_record(args: argparse.Namespace) -> None:
         "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,
@@ -740,9 +814,7 @@ def _load_resume_state(args: argparse.Namespace, parser: argparse.ArgumentParser
         args.scan_mode = persisted_scan_mode
 
 
-def display_completion_message(
-    args: argparse.Namespace, results_path: Path, web_url: str | None = None
-) -> None:
+def display_completion_message(args: argparse.Namespace, results_path: Path) -> None:
     console = Console()
     report_state = get_global_report_state()
 
@@ -781,28 +853,12 @@ def display_completion_message(
     results_text.append(str(results_path), style="#60a5fa")
     panel_parts.extend(["\n", results_text])
 
-    if web_url:
-        web_text = Text()
-        web_text.append("\n")
-        web_text.append("View in web", style="dim")
-        web_text.append("  ")
-        # OSC-8 hyperlink: clickable in modern terminals, falls back to the URL.
-        web_text.append(web_url, style=f"#60a5fa link {web_url}")
-        panel_parts.extend(["\n", web_text])
-
-        reopen_text = Text()
-        reopen_text.append("\n")
-        reopen_text.append("Reopen", style="dim")
-        reopen_text.append("       ")
-        reopen_text.append(f"strix view {args.run_name}", style="#22c55e")
-        panel_parts.extend(["\n", reopen_text])
-    else:
-        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])
+    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()
@@ -896,11 +952,18 @@ def main() -> None:
     # `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.viewer.cli import run_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()
 
     if args.config:
@@ -968,6 +1031,7 @@ def main() -> None:
 
     _telemetry_start_kwargs = {
         "model": load_settings().llm.model,
+        "auth_mode": codex.auth_mode(load_settings().llm.model),
         "scan_mode": args.scan_mode,
         "is_whitebox": is_whitebox_scan(args.targets_info),
         "interactive": not args.non_interactive,
@@ -1002,39 +1066,7 @@ def main() -> None:
 
     results_path = run_dir_for(args.run_name)
 
-    # For an interactive run, host the local viewer so the completion panel can
-    # show a clickable "View in web" link. Skipped in non-interactive/CI runs
-    # (no TTY to serve and it would block the process).
-    viewer_httpd = None
-    web_url = None
-    if not args.non_interactive and sys.stdout.isatty():
-        from strix.viewer.server import authorized_url, bundle_is_built, serve
-
-        if bundle_is_built():
-            try:
-                viewer_httpd, base_url, token = serve(results_path, open_browser=False)
-                # The completion panel's "View in web" link must authorize the
-                # browser, so hand it the tokened URL rather than the bare host.
-                web_url = authorized_url(base_url, token)
-                posthog.viewer_opened(source="post_scan", live=False)
-            except Exception:
-                logger.debug("could not start local viewer", exc_info=True)
-                viewer_httpd, web_url = None, None
-
-    display_completion_message(args, results_path, web_url=web_url)
-
-    if viewer_httpd is not None:
-        console = Console()
-        console.print("[dim]Hosting the local viewer. Press Ctrl-C to stop.[/]")
-        console.print()
-        try:
-            while True:
-                time.sleep(1)
-        except KeyboardInterrupt:
-            console.print("\n[dim]Viewer stopped.[/]")
-        finally:
-            viewer_httpd.shutdown()
-            viewer_httpd.server_close()
+    display_completion_message(args, results_path)
 
     if args.non_interactive:
         report_state = get_global_report_state()

strix/interface/tui/app.py

@@ -42,6 +42,12 @@ from strix.interface.tui.renderers.agent_message_renderer import AgentMessageRen
 from strix.interface.tui.renderers.user_message_renderer import UserMessageRenderer
 from strix.interface.utils import build_tui_stats_text
 from strix.report.state import ReportState, set_global_report_state
+from strix.report.writer import (
+    guess_language_name,
+    parse_fenced_code,
+    resolve_lexer,
+    safe_fence,
+)
 from strix.runtime import session_manager
 
 
@@ -330,12 +336,11 @@ class VulnerabilityDetailScreen(ModalScreen):  # type: ignore[misc]
             return "#65a30d"
         return "#6b7280"
 
-    def _highlight_python(self, code: str) -> Text:
+    def _highlight_python(self, code: str, language: str | None = None) -> Text:
         try:
-            from pygments.lexers import PythonLexer
             from pygments.styles import get_style_by_name
 
-            lexer = PythonLexer()
+            lexer = resolve_lexer(language, code)
             style = get_style_by_name("native")
             colors = {
                 token: f"#{style_def['color']}" for token, style_def in style if style_def["color"]
@@ -501,10 +506,11 @@ class VulnerabilityDetailScreen(ModalScreen):  # type: ignore[misc]
 
         poc_script_code = vuln.get("poc_script_code", "")
         if poc_script_code:
+            poc_language, poc_code = parse_fenced_code(poc_script_code)
             text.append("\n\n")
             text.append("PoC Code", style=self.FIELD_STYLE)
             text.append("\n")
-            text.append_text(self._highlight_python(poc_script_code))
+            text.append_text(self._highlight_python(poc_code, poc_language))
 
         remediation_steps = vuln.get("remediation_steps", "")
         if remediation_steps:
@@ -601,9 +607,12 @@ class VulnerabilityDetailScreen(ModalScreen):  # type: ignore[misc]
                 lines.append(vuln["poc_description"])
                 lines.append("")
             if vuln.get("poc_script_code"):
-                lines.append("```python")
-                lines.append(vuln["poc_script_code"])
-                lines.append("```")
+                poc_language, poc_code = parse_fenced_code(vuln["poc_script_code"])
+                fence_lang = poc_language or guess_language_name(poc_code)
+                fence = safe_fence(poc_code)
+                lines.append(f"{fence}{fence_lang}")
+                lines.append(poc_code)
+                lines.append(fence)
 
         if vuln.get("code_locations"):
             lines.extend(["", "## Code Analysis", ""])
@@ -619,7 +628,9 @@ class VulnerabilityDetailScreen(ModalScreen):  # type: ignore[misc]
                 if loc.get("label"):
                     lines.append(f"  {loc['label']}")
                 if loc.get("snippet"):
-                    lines.append(f"```\n{loc['snippet']}\n```")
+                    snippet = str(loc["snippet"])
+                    snippet_fence = safe_fence(snippet)
+                    lines.append(f"{snippet_fence}\n{snippet}\n{snippet_fence}")
                 if loc.get("fix_before") or loc.get("fix_after"):
                     lines.append("**Suggested Fix:**")
                     lines.append("```diff")
@@ -802,6 +813,7 @@ class StrixTUIApp(App):  # type: ignore[misc]
         self._scan_stop_event = threading.Event()
         self._scan_completed = threading.Event()
         self._scan_error: BaseException | None = None
+        self._error_noted_agents: set[str] = set()
 
         self._spinner_frame_index: int = 0
         self._sweep_num_squares: int = 6
@@ -1015,22 +1027,32 @@ class StrixTUIApp(App):  # type: ignore[misc]
             else:
                 self._agent_graph_sync_future = None
                 try:
-                    parent_of, statuses, names = future.result()
+                    parent_of, statuses, names, errors = future.result()
                 except Exception:
                     logger.exception("TUI agent graph sync failed")
                 else:
                     for agent_id, status in statuses.items():
+                        error = errors.get(agent_id)
                         self.live_view.upsert_agent(
                             agent_id,
                             name=names.get(agent_id, agent_id),
                             parent_id=parent_of.get(agent_id),
                             status=status,
+                            error_message=error,
                         )
+                        if status in {"failed", "crashed"} and error:
+                            if agent_id not in self._error_noted_agents:
+                                self._error_noted_agents.add(agent_id)
+                                self.live_view.record_agent_error(agent_id, error)
+                        else:
+                            self._error_noted_agents.discard(agent_id)
 
         if self._scan_loop is None or self._scan_loop.is_closed():
             return
 
-        async def collect() -> tuple[dict[str, str | None], dict[str, Any], dict[str, str]]:
+        async def collect() -> tuple[
+            dict[str, str | None], dict[str, Any], dict[str, str], dict[str, str]
+        ]:
             return await self.coordinator.graph_snapshot()
 
         self._agent_graph_sync_future = asyncio.run_coroutine_threadsafe(collect(), self._scan_loop)
@@ -1049,6 +1071,7 @@ class StrixTUIApp(App):  # type: ignore[misc]
                 "waiting": "⏸",
                 "completed": "🟢",
                 "failed": "🔴",
+                "crashed": "🔴",
                 "stopped": "■",
             }
 
@@ -1234,13 +1257,12 @@ class StrixTUIApp(App):  # type: ignore[misc]
             text.append(msg)
             return (text, Text(), False)
 
-        if status == "failed":
+        if status in {"failed", "crashed"}:
             error_msg = agent_data.get("error_message", "")
             text = Text()
-            if error_msg:
-                text.append(error_msg, style="red")
-            else:
-                text.append("Scan failed", style="red")
+            text.append(error_msg or "Agent failed", style="red")
+            text.append(" · ", style="dim")
+            text.append("Send message to resume", style="dim")
             self._stop_dot_animation()
             return (text, Text(), False)
 
@@ -1539,6 +1561,7 @@ class StrixTUIApp(App):  # type: ignore[misc]
             "waiting": "⏸",
             "completed": "🟢",
             "failed": "🔴",
+            "crashed": "🔴",
             "stopped": "■",
         }
 
@@ -1584,6 +1607,7 @@ class StrixTUIApp(App):  # type: ignore[misc]
             "waiting": "⏸",
             "completed": "🟢",
             "failed": "🔴",
+            "crashed": "🔴",
             "stopped": "■",
         }
 
@@ -1838,7 +1862,7 @@ class StrixTUIApp(App):  # type: ignore[misc]
                 webbrowser.open(self._viewer_url)
             return
         try:
-            from strix.viewer.server import authorized_url, bundle_is_built, serve
+            from strix.interface.viewer.server import authorized_url, bundle_is_built, serve
 
             if not bundle_is_built():
                 self._set_viewer_cta("[#eab308]Viewer UI not built[/]")

strix/interface/tui/live_view.py

@@ -86,6 +86,17 @@ class TuiLiveView:
             current["error_message"] = error_message
         current["updated_at"] = now
 
+    def record_agent_error(self, agent_id: str, error: str) -> None:
+        self._append_event(
+            agent_id,
+            "chat",
+            {
+                "role": "assistant",
+                "content": (f"An error occurred: {error}\nI'm now waiting for new instructions."),
+                "metadata": {"source": "agent_error"},
+            },
+        )
+
     def record_user_message(self, agent_id: str, content: str) -> None:
         self._append_event(
             agent_id,

strix/interface/tui/renderers/notes_renderer.py

@@ -7,6 +7,13 @@ from .base_renderer import BaseToolRenderer
 from .registry import register_tool_renderer
 
 
+def _author_label(note: dict[str, Any]) -> str:
+    if note.get("by_you"):
+        return "you"
+    agent_name = note.get("agent_name")
+    return str(agent_name).strip() if agent_name else ""
+
+
 @register_tool_renderer
 class CreateNoteRenderer(BaseToolRenderer):
     tool_name: ClassVar[str] = "create_note"
@@ -123,6 +130,9 @@ class ListNotesRenderer(BaseToolRenderer):
                     text.append("\n  - ")
                     text.append(title)
                     text.append(f" ({category})", style="dim")
+                    author = _author_label(note)
+                    if author:
+                        text.append(f" by {author}", style="dim")
 
                     if note_content:
                         text.append("\n    ")
@@ -156,6 +166,9 @@ class GetNoteRenderer(BaseToolRenderer):
             text.append("\n  ")
             text.append(title)
             text.append(f" ({category})", style="dim")
+            author = _author_label(note)
+            if author:
+                text.append(f" by {author}", style="dim")
             if content:
                 text.append("\n  ")
                 text.append(content, style="dim")

strix/interface/tui/renderers/reporting_renderer.py

@@ -1,11 +1,12 @@
 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.report.writer import parse_fenced_code, resolve_lexer
+
 from .base_renderer import BaseToolRenderer
 from .registry import register_tool_renderer
 
@@ -61,8 +62,8 @@ class CreateVulnerabilityReportRenderer(BaseToolRenderer):
         return None
 
     @classmethod
-    def _highlight_python(cls, code: str) -> Text:
-        lexer = PythonLexer()
+    def _highlight_code(cls, code: str, language: str | None) -> Text:
+        lexer = resolve_lexer(language, code)
         text = Text()
 
         for token_type, token_value in lexer.get_tokens(code):
@@ -234,10 +235,11 @@ class CreateVulnerabilityReportRenderer(BaseToolRenderer):
             text.append(poc_description)
 
         if poc_script_code:
+            poc_language, poc_code = parse_fenced_code(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))
+            text.append_text(cls._highlight_code(poc_code, poc_language))
 
         if remediation_steps:
             text.append("\n\n")
@@ -429,3 +431,117 @@ class CreateDependencyReportRenderer(BaseToolRenderer):
 
         css_classes = cls.get_css_classes("completed")
         return Static(padded, classes=css_classes)
+
+
+_LIST_SEVERITY_COLORS = {
+    "critical": "#dc2626",
+    "high": "#ea580c",
+    "medium": "#d97706",
+    "low": "#65a30d",
+    "info": "#0284c7",
+    "none": "#6b7280",
+}
+
+
+def _severity_style(severity: Any) -> str:
+    return _LIST_SEVERITY_COLORS.get(str(severity or "").lower(), "#d97706")
+
+
+def _author_label(report: dict[str, Any]) -> str:
+    if report.get("by_you"):
+        return "you"
+    agent_name = report.get("agent_name")
+    return str(agent_name).strip() if agent_name else ""
+
+
+@register_tool_renderer
+class ListReportsRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "list_reports"
+    css_classes: ClassVar[list[str]] = ["tool-call", "reporting-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        result = _coerce_dict(tool_data.get("result"))
+
+        text = Text()
+        text.append("◆ ", style="#ef4444")
+        text.append("reports", style="dim")
+
+        if isinstance(tool_data.get("result"), str) and str(tool_data["result"]).strip():
+            text.append("\n  ")
+            text.append(str(tool_data["result"]).strip(), style="dim")
+        elif result.get("success"):
+            total = result.get("total_count", 0)
+            reports = _coerce_list_of_dicts(result.get("reports"))
+            counts = _coerce_dict(result.get("severity_counts"))
+
+            text.append(f" ({total})", style="dim")
+            for sev, count in counts.items():
+                text.append("  ")
+                text.append(f"{sev} {count}", style=_severity_style(sev))
+
+            if not reports:
+                text.append("\n  ")
+                text.append("No reports filed yet", style="dim")
+            else:
+                for report in reports:
+                    rid = str(report.get("id", "")).strip()
+                    title = str(report.get("title", "")).strip() or "(untitled)"
+                    severity = str(report.get("severity", "")).strip()
+                    text.append("\n  - ")
+                    if severity:
+                        text.append(severity.upper(), style=f"bold {_severity_style(severity)}")
+                        text.append(" ")
+                    if rid:
+                        text.append(f"{rid} ", style="dim")
+                    text.append(title)
+                    author = _author_label(report)
+                    if author:
+                        text.append(f" ({author})", 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 GetReportRenderer(BaseToolRenderer):
+    tool_name: ClassVar[str] = "get_report"
+    css_classes: ClassVar[list[str]] = ["tool-call", "reporting-tool"]
+
+    @classmethod
+    def render(cls, tool_data: dict[str, Any]) -> Static:
+        result = _coerce_dict(tool_data.get("result"))
+
+        text = Text()
+        text.append("◆ ", style="#ef4444")
+        text.append("report read", style="dim")
+
+        report = _coerce_dict(result.get("report")) if result.get("success") else {}
+        if report:
+            rid = str(report.get("id", "")).strip()
+            title = str(report.get("title", "")).strip() or "(untitled)"
+            severity = str(report.get("severity", "")).strip()
+            text.append("\n  ")
+            if severity:
+                text.append(severity.upper(), style=f"bold {_severity_style(severity)}")
+                text.append(" ")
+            if rid:
+                text.append(f"{rid} ", style="dim")
+            text.append(title)
+            author = _author_label(report)
+            if author:
+                text.append(f" ({author})", style="dim")
+            target = str(report.get("target", "")).strip()
+            if target:
+                text.append("\n  ")
+                text.append(target, style="dim")
+        else:
+            text.append("\n  ")
+            detail = result.get("error") if result.get("success") is False else None
+            text.append(str(detail) if detail else "Loading...", style="dim")
+
+        css_classes = cls.get_css_classes("completed")
+        return Static(text, classes=css_classes)

strix/interface/utils.py

@@ -253,6 +253,20 @@ def _llm_usage(report_state: Any) -> dict[str, Any]:
     return usage if isinstance(usage, dict) else {}
 
 
+def _is_subscription(report_state: Any) -> bool:
+    """Whether this run uses a model subscription (no metered cost).
+
+    Prefers the run record so it's correct for hydrated/resumed runs; falls back
+    to current settings.
+    """
+    record = getattr(report_state, "run_record", None)
+    if isinstance(record, dict) and record.get("auth_mode"):
+        return record.get("auth_mode") == "subscription"
+    from strix.config import codex
+
+    return codex.auth_mode(load_settings().llm.model) == "subscription"
+
+
 def _int_stat(usage: dict[str, Any], key: str) -> int:
     try:
         return max(0, int(usage.get(key) or 0))
@@ -283,11 +297,16 @@ def _build_llm_usage_stats(
     *,
     live: bool = False,
 ) -> None:
+    subscription = _is_subscription(report_state)
     usage = _llm_usage(report_state)
     if not usage or _int_stat(usage, "requests") <= 0:
         stats_text.append("\n")
         stats_text.append("Cost ", style="dim")
-        stats_text.append("$0.0000 ", style="#fbbf24")
+        if subscription:
+            stats_text.append("$0.00 ", style="#22c55e")
+            stats_text.append("(subscription) ", style="dim")
+        else:
+            stats_text.append("$0.0000 ", style="#fbbf24")
         stats_text.append("· ", style="dim white")
         stats_text.append("Tokens ", style="dim")
         stats_text.append("0", style="white")
@@ -312,7 +331,12 @@ def _build_llm_usage_stats(
     stats_text.append("Output Tokens ", style="dim")
     stats_text.append(format_token_count(output_tokens), style="white")
 
-    if live or cost > 0:
+    if subscription:
+        stats_text.append("  ·  ", style="dim white")
+        stats_text.append("Cost ", style="dim")
+        stats_text.append("$0.00", style="#22c55e")
+        stats_text.append(" (subscription)", style="dim")
+    elif live or cost > 0:
         stats_text.append("  ·  ", style="dim white")
         stats_text.append("Cost ", style="dim")
         stats_text.append(f"${cost:.4f}", style="#fbbf24")
@@ -337,6 +361,9 @@ def build_live_stats_text(report_state: Any) -> Text:
     model = load_settings().llm.model or "unknown"
     stats_text.append("Model ", style="dim")
     stats_text.append(str(model), style="white")
+    if _is_subscription(report_state):
+        stats_text.append("  ·  ", style="dim white")
+        stats_text.append("ChatGPT subscription", style="#22c55e")
     stats_text.append("\n")
 
     vuln_count = len(report_state.vulnerability_reports)
@@ -379,6 +406,10 @@ def build_tui_stats_text(report_state: Any) -> Text:
 
     model = load_settings().llm.model or "unknown"
     stats_text.append(str(model), style="white")
+    subscription = _is_subscription(report_state)
+    if subscription:
+        stats_text.append("\n")
+        stats_text.append("ChatGPT subscription", style="#22c55e")
 
     usage = _llm_usage(report_state)
     if usage and _int_stat(usage, "total_tokens") > 0:
@@ -388,7 +419,10 @@ def build_tui_stats_text(report_state: Any) -> Text:
             style="white",
         )
         cost = _float_stat(usage, "cost")
-        if cost > 0:
+        if subscription:
+            stats_text.append(" · ", style="white")
+            stats_text.append("$0.00", style="white")
+        elif cost > 0:
             stats_text.append(" · ", style="white")
             stats_text.append(f"${cost:.2f}", style="white")
 
@@ -1147,9 +1181,7 @@ def read_target_list_file(path_str: str) -> list[str]:
             if (target := line.strip()) and not target.startswith("#")
         ]
     except UnicodeDecodeError as e:
-        raise ValueError(
-            f"Target list file '{path_str}' must be valid UTF-8 text: {e!s}"
-        ) from e
+        raise ValueError(f"Target list file '{path_str}' must be valid UTF-8 text: {e!s}") from e
     except OSError as e:
         raise ValueError(f"Failed to read target list file '{path_str}': {e!s}") from e
 

strix/interface/viewer/__init__.py

@@ -6,7 +6,7 @@ directly from the run's on-disk files. No cloud dependency, no file picker.
 
 from __future__ import annotations
 
-from strix.viewer.server import serve
+from strix.interface.viewer.server import serve
 
 
 __all__ = ["serve"]

strix/interface/viewer/auth.py

@@ -155,7 +155,7 @@ def _post_json(path: str, payload: dict[str, Any], *, timeout: int) -> tuple[int
         method="POST",
     )
     try:
-        with urllib.request.urlopen(request, timeout=timeout) as response:  # noqa: S310
+        with urllib.request.urlopen(request, timeout=timeout) as response:  # noqa: S310  # nosec B310
             return response.status, _parse_body(response.read())
     except urllib.error.HTTPError as exc:
         return exc.code, _parse_body(exc.read())

strix/interface/viewer/cli.py

@@ -16,8 +16,8 @@ from strix.core.paths import (
     run_record_path,
     runs_base_dir,
 )
-from strix.viewer.server import authorized_url, bundle_is_built, serve
-from strix.viewer.transcript import read_run_summary
+from strix.interface.viewer.server import authorized_url, bundle_is_built, serve
+from strix.interface.viewer.transcript import read_run_summary
 
 
 if TYPE_CHECKING:
@@ -58,7 +58,7 @@ def run_view(argv: list[str]) -> None:
     if not bundle_is_built():
         console.print(
             "[bold red]Viewer UI is not built.[/]\n"
-            "Build it with: [cyan]cd strix/viewer/frontend && npm ci && npm run build[/]"
+            "Build it with: [cyan]cd strix/interface/viewer/frontend && npm ci && npm run build[/]"
         )
         raise SystemExit(1)
 

strix/interface/viewer/frontend/package-lock.json

@@ -63,7 +63,6 @@
       "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.29.7",
         "@babel/generator": "^7.29.7",
@@ -1605,7 +1604,6 @@
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.17.tgz",
       "integrity": "sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "csstype": "^3.2.2"
       }
@@ -1616,7 +1614,6 @@
       "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
       "devOptional": true,
       "license": "MIT",
-      "peer": true,
       "peerDependencies": {
         "@types/react": "^19.2.0"
       }
@@ -1739,7 +1736,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.10.42",
         "caniuse-lite": "^1.0.30001803",
@@ -1920,7 +1916,6 @@
       "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
       "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==",
       "license": "ISC",
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
@@ -3571,7 +3566,6 @@
       "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -3623,7 +3617,6 @@
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.7.tgz",
       "integrity": "sha512-HNe9WslTbXmFK8o8cmwgAeJFSBvt1bPdHCVKtaaV+WlAN36mpT4hcRpwbf3fY56ar2oIXzsBpOAiIRHAdY0OlQ==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -3633,7 +3626,6 @@
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.7.tgz",
       "integrity": "sha512-t0BRVXvbiE/o20Hfw669rLbMCDWtYZLvmJigy2f0MxsXF+71pxhR3xOkspmsO8h3ZlNzyibAmtCa3l4lYKk6gQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "scheduler": "^0.27.0"
       },
@@ -4109,7 +4101,6 @@
       "integrity": "sha512-NTKlcQjlAK7MlQoyb6LgaqHc8sso/pVyUJYWMws3jg21uTJw/LddqIFPcPqP6PzpgbIcZyKI85sFE4HBrQDA8A==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "esbuild": "^0.25.0",
         "fdir": "^6.4.4",

strix/interface/viewer/frontend/src/components/RunDetails.tsx

@@ -100,6 +100,7 @@ export function RunDetails({
   const reasoning = num(rec(arr(usage.output_tokens_details)[0]).reasoning_tokens);
   const totalTokens = num(usage.total_tokens);
   const cost = num(usage.cost);
+  const subscription = str(raw.auth_mode) === "subscription";
 
   const sub = (n: number, word: string) => (
     <span className="text-[#666]"> ({formatNumber(n)} {word})</span>
@@ -175,6 +176,15 @@ export function RunDetails({
           {hasUsage ? (
             <dl className="space-y-2.5 tabular-nums">
               <Field label="Model">{models.length ? models.join(", ") : "n/a"}</Field>
+              {subscription && (
+                <Field label="Provider">
+                  <span className="inline-flex items-center gap-1.5">
+                    <span className="rounded-full border border-[#22c55e]/40 bg-[#22c55e]/10 px-2 py-0.5 text-[11px] text-[#22c55e]">
+                      ChatGPT subscription
+                    </span>
+                  </span>
+                </Field>
+              )}
               <Field label="Run time">{fmtDuration(durationSeconds)}</Field>
               {requests != null && <Field label="Requests">{formatNumber(requests)}</Field>}
               {inputTokens != null && (
@@ -190,7 +200,14 @@ export function RunDetails({
                 </Field>
               )}
               {totalTokens != null && <Field label="Total tokens">{formatNumber(totalTokens)}</Field>}
-              {cost != null && <Field label="Cost">${cost.toFixed(2)}</Field>}
+              {subscription ? (
+                <Field label="Cost">
+                  <span className="text-[#22c55e]">$0.00</span>
+                  <span className="text-[#666]"> (subscription)</span>
+                </Field>
+              ) : (
+                cost != null && <Field label="Cost">${cost.toFixed(2)}</Field>
+              )}
               {agents.length > 0 && <Field label="Agents">{formatNumber(agents.length)}</Field>}
             </dl>
           ) : (

strix/interface/viewer/frontend/src/components/live/tool-renderers/NotesRenderer.tsx

@@ -49,6 +49,9 @@ export default function NotesRenderer({ toolName, args, result }: ToolRendererPr
             <div className="mt-1.5 text-[#999] text-[13px]">
               {note.title ?? "(untitled)"}
               <span className="text-[#555] ml-1">({note.category ?? "general"})</span>
+              {(note.by_you || note.agent_name) && (
+                <span className="text-[#666] ml-1 text-xs">by {note.by_you ? "you" : note.agent_name}</span>
+              )}
             </div>
             {note.content && <div className="mt-1"><Markdown text={note.content} /></div>}
           </>
@@ -74,6 +77,9 @@ export default function NotesRenderer({ toolName, args, result }: ToolRendererPr
                 <span className="text-[#555] mr-1">-</span>
                 <span className="text-[#999]">{n.title ?? "(untitled)"}</span>
                 <span className="text-[#555] ml-1">({n.category ?? "general"})</span>
+                {(n.by_you || n.agent_name) && (
+                  <span className="text-[#666] ml-1 text-xs">by {n.by_you ? "you" : n.agent_name}</span>
+                )}
                 {n.content && <div className="ml-3"><Markdown text={n.content} /></div>}
               </div>
             ))}

strix/interface/viewer/frontend/src/components/live/tool-renderers/ReportListRenderer.tsx

@@ -0,0 +1,121 @@
+"use client";
+
+import type { ToolRendererProps } from "@/types/events";
+import { TruncatedText } from "./ToolCard";
+import Markdown from "./Markdown";
+
+const SEVERITY_COLORS: Record<string, string> = {
+  critical: "text-red-400", high: "text-orange-400", medium: "text-yellow-400",
+  low: "text-blue-400", info: "text-cyan-400", none: "text-[#888]",
+};
+
+interface ReportEntry {
+  id?: string;
+  title?: string;
+  severity?: string;
+  cvss?: number;
+  cve?: string;
+  cwe?: string;
+  target?: string;
+  endpoint?: string;
+  method?: string;
+  description_preview?: string;
+  description?: string;
+  agent_name?: string;
+  by_you?: boolean;
+}
+
+function authorTag(r: ReportEntry) {
+  if (!r.agent_name && !r.by_you) return null;
+  const label = r.by_you ? "you" : r.agent_name;
+  return <span className="text-[#666] text-xs ml-1.5">({label})</span>;
+}
+
+function sevBadge(severity: string | undefined) {
+  const sev = String(severity ?? "").toLowerCase();
+  const color = SEVERITY_COLORS[sev] ?? "text-yellow-400";
+  return <span className={`font-semibold text-[13px] ${color}`}>{sev.toUpperCase() || "—"}</span>;
+}
+
+export default function ReportListRenderer({ toolName, result }: ToolRendererProps) {
+  const res = result as Record<string, unknown> | null;
+  const ok = res != null && typeof res === "object" && res.success === true;
+
+  if (toolName === "get_report") {
+    const report = ok ? (res.report as ReportEntry | undefined) : undefined;
+    return (
+      <div>
+        <span className="text-red-400/80 font-semibold text-sm">report</span>
+        {report ? (
+          <div className="mt-1.5 space-y-2">
+            <div className="flex items-center gap-2 flex-wrap">
+              {sevBadge(report.severity)}
+              {report.cvss != null && <span className="text-[#888] text-[13px]">CVSS {report.cvss}</span>}
+              {report.id && <span className="text-[#555] font-mono text-[13px]">{report.id}</span>}
+              {report.cve && <span className="text-[#888] font-mono text-[13px]">{report.cve}</span>}
+              {report.cwe && <span className="text-[#888] font-mono text-[13px]">{report.cwe}</span>}
+              {(report.agent_name || report.by_you) && (
+                <span className="text-[#666] text-[13px]">{report.by_you ? "you" : report.agent_name}</span>
+              )}
+            </div>
+            {report.title && <div className="text-[15px] text-white/80 font-semibold">{report.title}</div>}
+            {(report.target || report.endpoint) && (
+              <div className="text-[13px] text-[#888] font-mono">
+                {report.target}{report.endpoint ? ` ${report.method ?? ""} ${report.endpoint}` : ""}
+              </div>
+            )}
+            {report.description && <TruncatedText text={report.description} maxLines={20} />}
+          </div>
+        ) : (
+          <div className="mt-1 text-[#555] text-xs">
+            {(res && typeof res === "object" && (res.error as string)) || "Report not found"}
+          </div>
+        )}
+      </div>
+    );
+  }
+
+  // list_reports
+  const rawReports = ok ? res.reports : null;
+  const reports: ReportEntry[] = Array.isArray(rawReports) ? (rawReports as ReportEntry[]) : [];
+  const total = ok && typeof res.total_count === "number" ? (res.total_count as number) : reports.length;
+  const counts = ok && res.severity_counts && typeof res.severity_counts === "object"
+    ? (res.severity_counts as Record<string, number>)
+    : {};
+  const countEntries = Object.entries(counts);
+
+  return (
+    <div>
+      <div className="flex items-center gap-2 flex-wrap">
+        <span className="text-red-400/80 font-semibold text-sm">reports</span>
+        <span className="text-[#555] text-[13px]">({total})</span>
+        {countEntries.map(([sev, n]) => (
+          <span key={sev} className="text-[13px]">
+            {sevBadge(sev)}<span className="text-[#888] ml-0.5">{n}</span>
+          </span>
+        ))}
+      </div>
+      {reports.length > 0 ? (
+        <div className="mt-1.5 space-y-1">
+          {reports.map((r, i) => (
+            <div key={r.id ?? i} className="text-[13px]">
+              <span className="text-[#555] mr-1">-</span>
+              {sevBadge(r.severity)}
+              {r.id && <span className="text-[#555] font-mono ml-1.5">{r.id}</span>}
+              <span className="text-[#999] ml-1.5">{r.title ?? "(untitled)"}</span>
+              {authorTag(r)}
+              {(r.target || r.endpoint) && (
+                <div className="ml-3 text-[#666] font-mono text-xs">
+                  {r.target}{r.endpoint ? ` ${r.method ?? ""} ${r.endpoint}` : ""}
+                </div>
+              )}
+              {r.description_preview && (
+                <div className="ml-3"><Markdown text={r.description_preview} /></div>
+              )}
+            </div>
+          ))}
+        </div>
+      ) : <div className="mt-1 text-[#555] text-xs">No reports filed yet</div>}
+    </div>
+  );
+}

strix/interface/viewer/frontend/src/components/live/tool-renderers/VulnReportRenderer.tsx

@@ -3,6 +3,7 @@
 import type { ToolRendererProps } from "@/types/events";
 import { TruncatedText } from "./ToolCard";
 import { MdCodeBlock } from "@/components/vulnerability/MdCodeBlock";
+import { parseFencedCode } from "@/lib/fenced-code";
 import Markdown from "./Markdown";
 
 const SEVERITY_COLORS: Record<string, string> = {
@@ -19,7 +20,7 @@ export default function VulnReportRenderer({ args, result }: ToolRendererProps)
   const method = (args.method as string) ?? "";
   const technicalAnalysis = (args.technical_analysis as string) ?? "";
   const pocDescription = (args.poc_description as string) ?? "";
-  const pocCode = (args.poc_script_code as string) ?? "";
+  const { language: pocLang, code: pocCode } = parseFencedCode((args.poc_script_code as string) ?? "");
   const remediation = (args.remediation_steps as string) ?? "";
   const cve = (args.cve as string) ?? "";
   const cwe = (args.cwe as string) ?? "";
@@ -59,7 +60,7 @@ export default function VulnReportRenderer({ args, result }: ToolRendererProps)
         <div>
           <span className="text-emerald-400/60 text-sm font-semibold">Proof of Concept</span>
           {pocDescription && <div className="mt-1"><Markdown text={pocDescription} /></div>}
-          {pocCode && <MdCodeBlock>{pocCode}</MdCodeBlock>}
+          {pocCode && <MdCodeBlock className={pocLang ? `language-${pocLang}` : undefined}>{pocCode}</MdCodeBlock>}
         </div>
       )}
       {remediation && (

strix/interface/viewer/frontend/src/components/live/tool-renderers/index.ts

@@ -12,6 +12,7 @@ import FileEditRenderer from "./FileEditRenderer";
 import ApplyPatchRenderer from "./ApplyPatchRenderer";
 import ViewImageRenderer from "./ViewImageRenderer";
 import VulnReportRenderer from "./VulnReportRenderer";
+import ReportListRenderer from "./ReportListRenderer";
 import ProxyRenderer from "./ProxyRenderer";
 import ThinkRenderer from "./ThinkRenderer";
 import AgentCommsRenderer from "./AgentCommsRenderer";
@@ -101,7 +102,7 @@ const CATEGORY_TOOLS: Record<ToolCategory, readonly string[]> = {
   filesystem: ["apply_patch", "view_image", "str_replace_editor", "list_files", "search_files"],
   // Caido proxy tools (legacy: send_request)
   proxy: ["list_requests", "view_request", "repeat_request", "list_sitemap", "view_sitemap_entry", "scope_rules", "send_request"],
-  reporting: ["create_vulnerability_report"],
+  reporting: ["create_vulnerability_report", "list_reports", "get_report"],
   thinking: ["think"],
   agents: ["create_agent", "agent_finish", "send_message_to_agent", "wait_for_message", "view_agent_graph", "stop_agent"],
   search: ["web_search"],
@@ -128,6 +129,8 @@ const RENDERER_OVERRIDES: Partial<Record<string, ComponentType<ToolRendererProps
   finish_scan: FinishRenderer,
   apply_patch: ApplyPatchRenderer,
   view_image: ViewImageRenderer,
+  list_reports: ReportListRenderer,
+  get_report: ReportListRenderer,
 };
 
 /**

strix/interface/viewer/frontend/src/components/vulnerability/MdCodeBlock.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { useState } from "react";
-import hljs from "@/lib/hljs";
+import { highlightCode } from "@/lib/hljs";
 import "highlight.js/styles/github-dark.css";
 import { Copy, Check } from "lucide-react";
 import { copyToClipboard } from "@/lib/vulnerability-utils";
@@ -17,7 +17,7 @@ export function MdCodeBlock({
 }) {
   const [copied, setCopied] = useState(false);
   const raw = String(children).replace(/\n$/, "");
-  const match = /language-(\w+)/.exec(className || "");
+  const match = /language-(\S+)/.exec(className || "");
   const isBlock = raw.includes("\n") || match;
 
   if (!isBlock) {
@@ -35,16 +35,7 @@ export function MdCodeBlock({
       : fileName
     : null;
 
-  let highlighted: string;
-  if (match) {
-    try {
-      highlighted = hljs.highlight(raw, { language: match[1], ignoreIllegals: true }).value;
-    } catch {
-      highlighted = hljs.highlightAuto(raw).value;
-    }
-  } else {
-    highlighted = hljs.highlightAuto(raw).value;
-  }
+  const highlighted = highlightCode(raw, match?.[1]);
 
   const lines = highlighted.split("\n");
 

strix/interface/viewer/frontend/src/components/vulnerability/PocBlock.tsx

@@ -1,12 +1,13 @@
 "use client";
 
 import { useState } from "react";
-import hljs from "@/lib/hljs";
+import { highlightCode } from "@/lib/hljs";
 import "highlight.js/styles/github-dark.css";
 import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
 import { Copy, Check } from "lucide-react";
 import { copyToClipboard } from "@/lib/vulnerability-utils";
+import { parseFencedCode } from "@/lib/fenced-code";
 import { rehypeCodeMeta, mdComponents } from "./MdCodeBlock";
 
 interface PocBlockProps {
@@ -20,9 +21,12 @@ export function PocBlock({ description, scriptCode, onCopy }: PocBlockProps) {
 
   if (!description && !scriptCode) return null;
 
+  const { language, code } = parseFencedCode(scriptCode);
+  const highlighted = highlightCode(code, language);
+
   const copy = () => {
-    if (!scriptCode) return;
-    copyToClipboard(scriptCode);
+    if (!code) return;
+    copyToClipboard(code);
     setCopied(true);
     setTimeout(() => setCopied(false), 2000);
     onCopy?.();
@@ -43,7 +47,7 @@ export function PocBlock({ description, scriptCode, onCopy }: PocBlockProps) {
             </ReactMarkdown>
           </div>
         )}
-        {scriptCode && (
+        {code && (
           <div className="group/poc relative rounded-md border border-[#2a2a2a] overflow-hidden">
             <div className="flex items-stretch">
               <span className="relative flex items-center text-[13px] text-[#999] font-mono px-4 py-2 border-r border-[#2a2a2a]">PoC Script<span className="absolute top-0 inset-x-0 h-0.5 bg-white/60 rounded-full" /></span>
@@ -64,7 +68,7 @@ export function PocBlock({ description, scriptCode, onCopy }: PocBlockProps) {
               <pre className="font-mono text-[12px] leading-[22px] whitespace-pre [font-variant-ligatures:none]">
                 <code
                   dangerouslySetInnerHTML={{
-                    __html: hljs.highlight(scriptCode, { language: "python" }).value,
+                    __html: highlighted,
                   }}
                 />
               </pre>

strix/interface/viewer/frontend/src/lib/fenced-code.ts

@@ -0,0 +1,27 @@
+export interface ParsedFencedCode {
+  language?: string;
+  code: string;
+}
+
+const FENCE_RE = /^```([^\n`]*)\r?\n([\s\S]*?)\r?\n?```$/;
+
+/**
+ * Agent-generated `poc_script_code` is stored wrapped in a markdown code fence
+ * that carries the language, e.g.
+ *
+ *     ```python
+ *     import requests
+ *     ```
+ *
+ * Renderers that show the value as bare code must not display the fence lines
+ * literally. This extracts the inner code and the fence's language tag. Returns
+ * the input unchanged (no language) when it isn't fenced.
+ */
+export function parseFencedCode(raw: string | null | undefined): ParsedFencedCode {
+  if (!raw) return { code: "" };
+  const match = FENCE_RE.exec(raw.trim());
+  if (!match) return { code: raw };
+  const info = match[1].trim();
+  const language = info ? info.split(/\s+/)[0] : undefined;
+  return { language: language || undefined, code: match[2] };
+}

strix/interface/viewer/frontend/src/lib/hljs.ts

@@ -0,0 +1,32 @@
+import hljs from "highlight.js/lib/common";
+import http from "highlight.js/lib/languages/http";
+import nginx from "highlight.js/lib/languages/nginx";
+import apache from "highlight.js/lib/languages/apache";
+import dockerfile from "highlight.js/lib/languages/dockerfile";
+import properties from "highlight.js/lib/languages/properties";
+
+hljs.registerLanguage("http", http);
+hljs.registerLanguage("nginx", nginx);
+hljs.registerLanguage("apache", apache);
+hljs.registerLanguage("dockerfile", dockerfile);
+hljs.registerLanguage("properties", properties);
+
+/**
+ * Highlight code, preferring an explicit language when it's recognized,
+ * otherwise auto-detecting. Falls back to Python when auto-detection is
+ * inconclusive, since legacy (unfenced) PoC scripts are Python.
+ */
+export function highlightCode(code: string, language?: string | null): string {
+  try {
+    if (language && hljs.getLanguage(language)) {
+      return hljs.highlight(code, { language, ignoreIllegals: true }).value;
+    }
+    const auto = hljs.highlightAuto(code);
+    if (auto.language) return auto.value;
+    return hljs.highlight(code, { language: "python", ignoreIllegals: true }).value;
+  } catch {
+    return hljs.highlight(code, { language: "python", ignoreIllegals: true }).value;
+  }
+}
+
+export default hljs;

strix/interface/viewer/frontend/vite.config.ts

@@ -5,7 +5,7 @@ import { fileURLToPath, URL } from "node:url";
 
 // The viewer is served as static files by a stdlib Python server on an
 // arbitrary ephemeral port, so all asset URLs must be relative (base: "./").
-// The build output is committed at strix/viewer/static and shipped.
+// The build output is committed at strix/interface/viewer/static and shipped.
 export default defineConfig({
   base: "./",
   plugins: [react(), tailwindcss()],

strix/interface/viewer/report_pdf.py

@@ -38,7 +38,7 @@ from reportlab.platypus import (
     TableStyle,
 )
 
-from strix.viewer.transcript import (
+from strix.interface.viewer.transcript import (
     primary_target,
     read_run_summary,
     read_vulnerabilities,
@@ -151,19 +151,35 @@ def _styles() -> dict[str, ParagraphStyle]:
         "Finding", fontName=_SANS_BOLD, fontSize=13, leading=17, textColor=_INK, spaceBefore=6
     )
     styles["field_label"] = ParagraphStyle(
-        "FieldLabel", fontName=_SANS_BOLD, fontSize=8.5, leading=12, textColor=_MUTED,
-        spaceBefore=10, spaceAfter=2,
+        "FieldLabel",
+        fontName=_SANS_BOLD,
+        fontSize=8.5,
+        leading=12,
+        textColor=_MUTED,
+        spaceBefore=10,
+        spaceAfter=2,
     )
     styles["body"] = ParagraphStyle(
         "Body", fontName=_SANS, fontSize=10, leading=15, textColor=_TEXT, spaceAfter=8
     )
     styles["md_heading"] = ParagraphStyle(
-        "MdHeading", fontName=_SANS_BOLD, fontSize=11, leading=15, textColor=_INK,
-        spaceBefore=10, spaceAfter=4,
+        "MdHeading",
+        fontName=_SANS_BOLD,
+        fontSize=11,
+        leading=15,
+        textColor=_INK,
+        spaceBefore=10,
+        spaceAfter=4,
     )
     styles["bullet"] = ParagraphStyle(
-        "Bullet", fontName=_SANS, fontSize=10, leading=15, textColor=_TEXT,
-        leftIndent=16, firstLineIndent=-11, spaceAfter=3,
+        "Bullet",
+        fontName=_SANS,
+        fontSize=10,
+        leading=15,
+        textColor=_TEXT,
+        leftIndent=16,
+        firstLineIndent=-11,
+        spaceAfter=3,
     )
     styles["meta_inline"] = ParagraphStyle(
         "MetaInline", fontName=_SANS, fontSize=9, leading=13, textColor=_MUTED, spaceBefore=4
@@ -172,23 +188,44 @@ def _styles() -> dict[str, ParagraphStyle]:
     # a bordered paragraph's top padding, so too small a gap lets the background
     # box bleed up over the field label above it.
     styles["code"] = ParagraphStyle(
-        "Code", fontName=_MONO, fontSize=8, leading=11, textColor=_TEXT,
-        backColor=_LIGHT_BG, borderColor=_BORDER, borderWidth=0.5, borderPadding=8,
-        spaceBefore=12, spaceAfter=12,
+        "Code",
+        fontName=_MONO,
+        fontSize=8,
+        leading=11,
+        textColor=_TEXT,
+        backColor=_LIGHT_BG,
+        borderColor=_BORDER,
+        borderWidth=0.5,
+        borderPadding=8,
+        spaceBefore=12,
+        spaceAfter=12,
     )
     styles["count"] = ParagraphStyle(
         "Count", fontName=_SANS_BOLD, fontSize=30, leading=32, alignment=TA_CENTER
     )
     styles["count_label"] = ParagraphStyle(
-        "CountLabel", fontName=_SANS_BOLD, fontSize=8, leading=12, textColor=_MUTED,
-        alignment=TA_CENTER, spaceBefore=4,
+        "CountLabel",
+        fontName=_SANS_BOLD,
+        fontSize=8,
+        leading=12,
+        textColor=_MUTED,
+        alignment=TA_CENTER,
+        spaceBefore=4,
     )
     styles["badge"] = ParagraphStyle(
-        "Badge", fontName=_SANS_BOLD, fontSize=9, leading=11, textColor=colors.white,
+        "Badge",
+        fontName=_SANS_BOLD,
+        fontSize=9,
+        leading=11,
+        textColor=colors.white,
         alignment=TA_CENTER,
     )
     styles["confidential"] = ParagraphStyle(
-        "Confidential", fontName=_SANS_BOLD, fontSize=9, leading=12, textColor=colors.white,
+        "Confidential",
+        fontName=_SANS_BOLD,
+        fontSize=9,
+        leading=12,
+        textColor=colors.white,
         alignment=TA_CENTER,
     )
     return styles
@@ -256,8 +293,10 @@ def _severity_grid(styles: dict[str, ParagraphStyle], counts: dict[str, int]) ->
         color = _SEVERITY_COLORS[name]
         count_style = ParagraphStyle(f"Count{name}", parent=styles["count"], textColor=color)
         cells.append(
-            [Paragraph(str(counts.get(name, 0)), count_style),
-             Paragraph(name.upper(), styles["count_label"])]
+            [
+                Paragraph(str(counts.get(name, 0)), count_style),
+                Paragraph(name.upper(), styles["count_label"]),
+            ]
         )
     col = (_PAGE_W - 40 * mm) / 4
     table = Table([cells], colWidths=[col] * 4)
@@ -320,8 +359,10 @@ def _cover(
         ("DURATION", _duration(record.get("start_time"), record.get("end_time"))),
     ]
     meta_table = Table(
-        [[Paragraph(label, styles["meta_label"]), Paragraph(_esc(value), styles["meta_value"])]
-         for label, value in meta_rows],
+        [
+            [Paragraph(label, styles["meta_label"]), Paragraph(_esc(value), styles["meta_value"])]
+            for label, value in meta_rows
+        ],
         colWidths=[38 * mm, _PAGE_W - 40 * mm - 38 * mm],
     )
     meta_table.setStyle(
@@ -462,6 +503,18 @@ def _markdown_flowables(  # noqa: PLR0915 - cohesive block parser, splitting hur
     return flow
 
 
+_FENCE_RE = re.compile(r"^```([^\n`]*)\n(.*?)\n?```$", re.DOTALL)
+
+
+def _strip_code_fence(value: Any) -> Any:
+    """Drop a wrapping markdown code fence so raw-code fields don't show the
+    ``` ```lang ``` marker lines literally in the PDF."""
+    if not isinstance(value, str):
+        return value
+    match = _FENCE_RE.match(value.strip())
+    return match.group(2) if match else value
+
+
 def _field_block(
     styles: dict[str, ParagraphStyle], label: str, value: Any, *, code: bool = False
 ) -> list[Flowable]:
@@ -503,7 +556,8 @@ def _finding_flowables(
     story.extend(_field_block(styles, "Impact", vuln.get("impact")))
     story.extend(_field_block(styles, "Technical analysis", vuln.get("technical_analysis")))
     story.extend(_field_block(styles, "Proof of concept", vuln.get("poc_description")))
-    story.extend(_field_block(styles, "PoC script", vuln.get("poc_script_code"), code=True))
+    poc_script = _strip_code_fence(vuln.get("poc_script_code"))
+    story.extend(_field_block(styles, "PoC script", poc_script, code=True))
     story.extend(_field_block(styles, "Evidence", vuln.get("evidence"), code=True))
 
     remediation = vuln.get("remediation_steps")

strix/interface/viewer/server.py

@@ -27,8 +27,8 @@ from typing import TYPE_CHECKING, Any
 from urllib.parse import parse_qs, unquote, urlencode, urlsplit
 
 from strix.core.paths import run_record_path
-from strix.viewer import auth
-from strix.viewer.transcript import (
+from strix.interface.viewer import auth
+from strix.interface.viewer.transcript import (
     build_run_state,
     primary_target,
     read_report_markdown,
@@ -367,7 +367,7 @@ def _make_handler(state: _ViewerState) -> type[BaseHTTPRequestHandler]:
                 self._send_json(HTTPStatus.CONFLICT, {"error": "run_not_finished"})
                 return
 
-            from strix.viewer.report_pdf import build_encrypted_report
+            from strix.interface.viewer.report_pdf import build_encrypted_report
 
             pdf_bytes, password, filename = build_encrypted_report(run_dir)
             run_name = str(summary.get("run_name") or run_dir.name)