dreadnode 2.0.44__tar.gz → 2.0.45__tar.gz

{dreadnode-2.0.44 → dreadnode-2.0.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dreadnode
-Version: 2.0.44
+Version: 2.0.45
 Summary: Dreadnode SDK
 Project-URL: Homepage, https://dreadnode.io
 Project-URL: Documentation, https://docs.dreadnode.io

{dreadnode-2.0.44 → dreadnode-2.0.45}/dreadnode/airt/_base.py

@@ -89,12 +89,27 @@ class BlackBoxAttack:
         self.rng = np.random.default_rng(seed)
         self.airt_assessment_id = airt_assessment_id
         self.airt_target_model = airt_target_model or target.name
-        self.airt_goal = airt_goal or self.default_goal
+        # Make the default goal target-aware so the same objective against
+        # different models counts as distinct goals on the dashboard (e.g. evasion
+        # of the fraud, digits, and sentiment classifiers = 3 goals, not 1). An
+        # explicit airt_goal is respected verbatim; only the default is suffixed.
+        self.airt_goal = airt_goal or (
+            f"{self.default_goal} on {self.airt_target_model}"
+            if self.airt_target_model
+            else self.default_goal
+        )
         self.airt_goal_category = airt_goal_category or self.default_goal_category
         self._query_count = 0
         #: A sample of real (input -> prediction) pairs so the finding can show
         #: the actual queries the attacker sent, not just the total count.
         self._query_samples: list[dict[str, t.Any]] = []
+        #: Count of trial spans emitted this run. Each algorithm iteration is one
+        #: trial (mirroring how a generative Study counts a trial per step), so the
+        #: platform can count trials / incurred budget for traditional-ML attacks.
+        self._trials_emitted = 0
+        #: Hard safety cap on trial spans so a pathologically long loop cannot
+        #: explode the trace tree.
+        self._max_trial_spans = 1000
 
     # -- target I/O -------------------------------------------------------- #
     async def _query(self, xs: t.Sequence[QueryInput]) -> list[Prediction]:
@@ -146,28 +161,74 @@ class BlackBoxAttack:
         metrics: dict[str, float] | None = None,
         **attrs: t.Any,
     ) -> None:
-        """Emit a point-in-time span for one algorithm iteration, recording the
+        """Emit a **trial** span for one algorithm iteration, recording the
         intermediate adversarial state so the full attack trajectory is
-        inspectable in the Traces tab.
+        inspectable in the Traces tab and every iteration is counted as a trial.
+
+        One iteration == one trial: this mirrors how a generative ``Study`` emits
+        a trial span per refinement step, so the platform counts trials (and the
+        incurred query budget) for traditional-ML attacks the same way. The span
+        carries the AIRT assessment/attack attributes and is a child of the run's
+        ``study`` span (opened in :meth:`run`), which is how ClickHouse links a
+        trial to its assessment.
 
         ``input`` is the current candidate (perturbed text / feature vector /
         image preview) the attacker sent; ``output`` is the target's response at
-        this step (predicted label + confidence); ``metrics`` are the scalar
-        signals (distance, confidence, fidelity) plotted over the run. Capped
-        (first 20 iterations, then every 10th) so a long run does not explode the
+        this step; ``metrics`` are the scalar signals (distance, confidence,
+        fidelity) plotted over the run. The lightweight trial span is emitted
+        every iteration; the heavier input/output previews are attached only for
+        the first 20 iterations then every 10th, so a long run does not bloat the
         trace tree."""
-        if iteration >= 20 and iteration % 10 != 0:
+        if self._trials_emitted >= self._max_trial_spans:
             return
-        with self._phase(f"step {iteration}", iteration=iteration, **attrs) as span:
-            if span is None or not hasattr(span, "log_input"):
+        self._trials_emitted += 1
+        heavy = iteration < 20 or iteration % 10 == 0
+        with self._trial(iteration, **attrs) as span:
+            if span is None or not hasattr(span, "log_metric"):
                 return
             with suppress(Exception):
-                if input is not None:
-                    span.log_input("candidate", input)
-                if output is not None:
-                    span.log_output("prediction", output)
                 for key, value in (metrics or {}).items():
                     span.log_metric(key, float(value), step=iteration)
+                if heavy and input is not None and hasattr(span, "log_input"):
+                    span.log_input("candidate", input)
+                if heavy and output is not None and hasattr(span, "log_output"):
+                    span.log_output("prediction", output)
+
+    def _trial(self, iteration: int, **attrs: t.Any) -> t.Any:
+        """Open a ``trial`` span for one iteration, tagged with the AIRT
+        assessment/attack attributes so it is counted against this assessment."""
+        try:
+            from dreadnode.tracing.spans import trial_span
+
+            ctx = trial_span(
+                trial_id=f"{self._attack_name}-{iteration}-{self._trials_emitted}",
+                step=int(iteration),
+                airt_assessment_id=self.airt_assessment_id,
+                airt_trial_index=int(iteration),
+                airt_attack_name=self._attack_name,
+                airt_attack_domain=self.attack_domain,
+                airt_target_model=self.airt_target_model,
+                airt_goal=self.airt_goal,
+                airt_goal_category=self.airt_goal_category,
+                airt_input_modality=self.modality,
+            )
+        except Exception:
+            return nullcontext()
+        if not attrs:
+            return ctx
+        # Fold any per-iteration attrs (e.g. distance norm) onto the span.
+        from contextlib import contextmanager
+
+        @contextmanager
+        def _wrapped() -> t.Iterator[t.Any]:
+            with ctx as span:
+                if span is not None and hasattr(span, "set_attribute"):
+                    with suppress(Exception):
+                        for key, value in attrs.items():
+                            span.set_attribute(str(key), value)
+                yield span
+
+        return _wrapped()
 
     # -- run scaffold ------------------------------------------------------ #
     @property

{dreadnode-2.0.44 → dreadnode-2.0.45}/dreadnode/app/cli/evaluation.py

@@ -792,7 +792,9 @@ def create(
         max_steps: Maximum agent tool/generation steps per sample.
             Enforced via a headless session policy; the task timeout still
             applies as a wall-clock bound.
-        cleanup_policy: Sandbox cleanup policy.
+        cleanup_policy: Sandbox cleanup policy. Hosted E2B evaluations support
+            only ``always``; ``on_success`` is available on Docker and
+            OpenSandbox deployments.
         judge_model: Override the judge model for all tasks in this evaluation.
         egress: Additional outbound destination for this run's sandboxes, as an
             FQDN, a '*.suffix' wildcard, an IP, or a CIDR (repeatable). Unions

{dreadnode-2.0.44 → dreadnode-2.0.45}/dreadnode/app/cli/main.py

@@ -1,9 +1,11 @@
 """Root cyclopts App with top-level commands (tui, login, serve)."""
 
+import importlib
 import importlib.metadata
 import os
 import secrets
 import sys
+import threading
 import time
 import typing as t
 
@@ -14,25 +16,8 @@ import cyclopts
 from loguru import logger
 from rich.panel import Panel
 
-from dreadnode.app.cli.airt import cli as airt_cli
 from dreadnode.app.cli.args import RESUME_PICK_SENTINEL, PlatformArgs, TuiArgs
-from dreadnode.app.cli.capability import cli as capability_cli
-from dreadnode.app.cli.dataset import cli as dataset_cli
-from dreadnode.app.cli.environment import cli as environment_cli
-from dreadnode.app.cli.evaluation import cli as evaluation_cli
-from dreadnode.app.cli.inference_model import cli as inference_model_cli
-from dreadnode.app.cli.judge import cli as judge_cli
-from dreadnode.app.cli.model import cli as model_cli
-from dreadnode.app.cli.optimize import cli as optimize_cli
-from dreadnode.app.cli.runtime import cli as runtime_cli
-from dreadnode.app.cli.sandbox import cli as sandbox_cli
-from dreadnode.app.cli.secret import cli as secret_cli
-from dreadnode.app.cli.session import cli as session_cli
 from dreadnode.app.cli.shared import console, print_error, print_success
-from dreadnode.app.cli.task import cli as task_cli
-from dreadnode.app.cli.task_set import cli as task_set_cli
-from dreadnode.app.cli.train import cli as train_cli
-from dreadnode.app.cli.worlds import cli as worlds_cli
 from dreadnode.app.model_catalog import resolve_model
 from dreadnode.core.tls import format_tls_error
 
@@ -68,7 +53,55 @@ def _render_profile_context(profile: t.Any) -> str:
 # Root app
 # ---------------------------------------------------------------------------
 
-cli = cyclopts.App(
+
+class _LazyCommandApp(cyclopts.App):
+    """Root app that resolves subcommands from the tokens it is handed.
+
+    Subcommands import on demand (see ``_LAZY_COMMANDS`` below), so anything
+    reaching this object directly rather than through ``run()`` would otherwise
+    see only the commands defined in this module. That failure is silent:
+    cyclopts answers an unregistered command by printing the *root* help and
+    exiting 0, so the caller gets a plausible wrong answer instead of an error.
+
+    Preparing inside the entry points covers every caller rather than the two
+    that happen to be known today — the agent's ``dreadnode_cli`` tool calls
+    ``cli(tokens)``, tests call ``parse_args``, and the next one has not been
+    written yet. Registration is idempotent, so the repeat calls cyclopts makes
+    internally cost a set lookup.
+    """
+
+    @staticmethod
+    def _as_tokens(tokens: "None | str | t.Iterable[str]") -> list[str]:
+        if tokens is None:
+            return sys.argv[1:]
+        if isinstance(tokens, str):
+            return tokens.split()
+        return list(tokens)
+
+    def __call__(self, tokens: "None | str | t.Iterable[str]" = None, **kwargs: t.Any) -> t.Any:
+        _prepare_commands(self._as_tokens(tokens))
+        return super().__call__(tokens, **kwargs)
+
+    def parse_args(  # type: ignore[override]
+        self, tokens: "None | str | t.Iterable[str]" = None, **kwargs: t.Any
+    ) -> t.Any:
+        _prepare_commands(self._as_tokens(tokens))
+        return super().parse_args(tokens, **kwargs)
+
+    def parse_known_args(  # type: ignore[override]
+        self, tokens: "None | str | t.Iterable[str]" = None, **kwargs: t.Any
+    ) -> t.Any:
+        _prepare_commands(self._as_tokens(tokens))
+        return super().parse_known_args(tokens, **kwargs)
+
+    def parse_commands(  # type: ignore[override]
+        self, tokens: "None | str | t.Iterable[str]" = None, **kwargs: t.Any
+    ) -> t.Any:
+        _prepare_commands(self._as_tokens(tokens))
+        return super().parse_commands(tokens, **kwargs)
+
+
+cli = _LazyCommandApp(
     name="dreadnode",
     help="Dreadnode CLI — agent development and platform tooling.",
     version=_get_version_safe(),
@@ -85,23 +118,99 @@ cli["--install-completion"].group = "Meta"
 # Subcommands
 # ---------------------------------------------------------------------------
 
-cli.command(airt_cli)
-cli.command(capability_cli)
-cli.command(dataset_cli)
-cli.command(environment_cli, alias="env")
-cli.command(evaluation_cli)
-cli.command(inference_model_cli, alias="llm")
-cli.command(judge_cli)
-cli.command(model_cli)
-cli.command(optimize_cli)
-cli.command(runtime_cli)
-cli.command(sandbox_cli)
-cli.command(secret_cli)
-cli.command(session_cli)
-cli.command(task_cli)
-cli.command(task_set_cli)
-cli.command(train_cli)
-cli.command(worlds_cli)
+# Subcommands are imported when one is invoked, not when the CLI loads.
+#
+# Registering them eagerly meant every invocation paid for every command:
+# `dreadnode serve` imported the AIRT tree and, under it, pandas, pyarrow,
+# numpy and optuna, none of which a running runtime uses. That was the
+# majority of a runtime's cold start (ENG-8259).
+#
+# This is the same lazy-table shape the SDK already uses for its own
+# subpackages (`__lazy_submodules__` and friends in `dreadnode/__init__.py`);
+# cyclopts has no native support for deferred subcommands, so registration is
+# driven from the invoked token instead.
+#
+# Keys are the command name as it is typed. The value is the module holding
+# the sub-app and its alias, if it has one.
+_LAZY_COMMANDS: dict[str, tuple[str, str | None]] = {
+    "airt": ("dreadnode.app.cli.airt", None),
+    "capability": ("dreadnode.app.cli.capability", None),
+    "dataset": ("dreadnode.app.cli.dataset", None),
+    "environment": ("dreadnode.app.cli.environment", "env"),
+    "evaluation": ("dreadnode.app.cli.evaluation", None),
+    "inference-model": ("dreadnode.app.cli.inference_model", "llm"),
+    "judge": ("dreadnode.app.cli.judge", None),
+    "model": ("dreadnode.app.cli.model", None),
+    "optimize": ("dreadnode.app.cli.optimize", None),
+    "runtime": ("dreadnode.app.cli.runtime", None),
+    "sandbox": ("dreadnode.app.cli.sandbox", None),
+    "secret": ("dreadnode.app.cli.secret", None),
+    "session": ("dreadnode.app.cli.session", None),
+    "task": ("dreadnode.app.cli.task", None),
+    "task-set": ("dreadnode.app.cli.task_set", None),
+    "train": ("dreadnode.app.cli.train", None),
+    "worlds": ("dreadnode.app.cli.worlds", None),
+}
+
+_COMMAND_ALIASES: dict[str, str] = {
+    alias: name for name, (_, alias) in _LAZY_COMMANDS.items() if alias
+}
+
+_registered_commands: set[str] = set()
+# `dreadnode serve` hosts concurrent sessions and the agent's CLI tool is
+# dispatched with asyncio.to_thread, so two threads can reach the same
+# unregistered command at once. cyclopts raises CommandCollisionError on a
+# duplicate name, which would fail the second caller's invocation.
+_registration_lock = threading.Lock()
+
+
+def register_command(name: str) -> bool:
+    """Register one lazy subcommand, importing its module. True if it exists.
+
+    Idempotent, so a caller may register a command that is already present.
+    """
+    primary = _COMMAND_ALIASES.get(name, name)
+    entry = _LAZY_COMMANDS.get(primary)
+    if entry is None:
+        return False
+    if primary in _registered_commands:
+        return True
+    with _registration_lock:
+        # Re-check under the lock: another thread may have registered it while
+        # this one waited, and registering twice raises.
+        if primary not in _registered_commands:
+            module_path, alias = entry
+            subapp = importlib.import_module(module_path).cli
+            if alias:
+                cli.command(subapp, alias=alias)
+            else:
+                cli.command(subapp)
+            _registered_commands.add(primary)
+    return True
+
+
+def register_all_commands() -> None:
+    """Register every subcommand, importing all of them.
+
+    Needed whenever the whole command tree has to be visible at once: help,
+    shell completion, an unrecognised command that should be reported against
+    the full list, and tests that assert on the CLI surface.
+    """
+    for name in _LAZY_COMMANDS:
+        register_command(name)
+
+
+def _prepare_commands(tokens: t.Sequence[str]) -> None:
+    """Import whatever the invocation needs, and nothing else."""
+    for token in tokens:
+        if token.startswith("-"):
+            continue  # a flag before the command, e.g. `dreadnode --version`
+        if register_command(token):
+            return
+        if token in cli:
+            return  # defined here rather than in a subcommand module
+        break  # unknown: fall through so the error lists every command
+    register_all_commands()
 
 
 # ---------------------------------------------------------------------------
@@ -115,6 +224,7 @@ def _meta(
 ) -> None:
     try:
         console.print()
+        _prepare_commands(tokens)
         cli(tokens)
     except Exception as exc:
         if DEBUG:
@@ -645,6 +755,11 @@ def run(argv: list[str] | None = None) -> None:
     try:
         tokens = argv if argv is not None else sys.argv[1:]
         tokens = _rewrite_bare_resume(list(tokens))
+        # Before dispatch, not inside the meta handler: cyclopts answers
+        # `--help` and `--version` on the meta app itself and never runs the
+        # handler body, so registering there would leave the help listing
+        # showing only the commands defined in this module.
+        _prepare_commands(tokens)
         cli.meta(tokens)
     except SystemExit as exc:
         if exc.code not in (None, 0):

{dreadnode-2.0.44 → dreadnode-2.0.45}/dreadnode/app/server/app.py

@@ -611,6 +611,31 @@ def create_agent(
 # =============================================================================
 
 
+def _configure_litellm_env() -> None:
+    """Configure litellm through the environment, before anything imports it.
+
+    litellm reads these at import time:
+
+        drop_params   = bool(os.getenv("LITELLM_DROP_PARAMS", False))
+        modify_params = bool(os.getenv("LITELLM_MODIFY_PARAMS", False))
+
+    so setting them configures whoever imports litellm first — the warm thread,
+    or a request that beats it. Going through the environment is what lets the
+    import itself come off the readiness path: this needs no import of its own.
+
+    ``suppress_debug_info`` has no environment hook and is set as an attribute
+    by the warm thread. It only silences debug prints, so the warm window costs
+    noise rather than correctness.
+
+    ``LITELLM_LOCAL_MODEL_COST_MAP`` stops litellm fetching its model-cost map
+    over the network on first import. The platform sets it in the sandbox
+    environment; this covers a local ``dreadnode serve``.
+    """
+    os.environ.setdefault("LITELLM_DROP_PARAMS", "True")
+    os.environ.setdefault("LITELLM_MODIFY_PARAMS", "True")
+    os.environ.setdefault("LITELLM_LOCAL_MODEL_COST_MAP", "True")
+
+
 def _warm_litellm() -> None:
     """Import litellm so the first chat turn doesn't pay the cold-import cost.
 
@@ -622,10 +647,13 @@ def _warm_litellm() -> None:
     """
     _t0 = time.perf_counter()
     try:
-        # Skip the httpx.get() to GitHub for model pricing on import.
-        os.environ.setdefault("LITELLM_LOCAL_MODEL_COST_MAP", "True")
-        import litellm
-        import litellm.exceptions
+        # Belt and braces: the lifecycle sets these, but this runs on other
+        # paths too and must never be the one that imports litellm unconfigured.
+        _configure_litellm_env()
+        with startup_clock.timed("litellm.import"):
+            import litellm
+            import litellm.exceptions
+        startup_clock.mark("litellm_imported")
 
         litellm.drop_params = True
         litellm.suppress_debug_info = True  # ty: ignore[invalid-assignment]
@@ -695,23 +723,18 @@ async def server_lifecycle() -> t.AsyncIterator[None]:
         await registry.worker_manager.start(registry)
     state.startup.mark("workers_started")
 
-    # Set critical litellm flags eagerly (before background import) so they
-    # are active even if a chat request arrives before warmup completes.
-    # This import is the whole litellm cost on the readiness path; the warm
-    # thread below finds it already done. Timed so that shows up as its own
-    # number rather than hiding inside "connecting".
-    try:
-        with startup_clock.timed("litellm.import"):
-            import litellm
-        state.startup.mark("litellm_imported")
-
-        litellm.drop_params = True
-        litellm.suppress_debug_info = True  # ty: ignore[invalid-assignment]
-    except Exception:  # noqa: S110 - _warm_litellm will retry the full import
-        pass
-
-    # Warm litellm in a background thread so the health endpoint goes live
-    # immediately while the ~2s import finishes in the background.
+    _configure_litellm_env()
+
+    # litellm is deliberately NOT imported here. It was the largest single item
+    # on the readiness path (~1.8s on a laptop, ~4.3s on a sandbox) and it ran
+    # last, so readiness waited on it (ENG-8259). The warm thread below still
+    # shifts the import cost off the first chat turn; it just no longer holds
+    # readiness open while it does.
+    #
+    # The flags this block used to import litellm to set are covered by the
+    # environment above. Note that LiteLLMGenerator.__post_model_init__ looks
+    # like it sets them too, but that is not a pydantic hook and never runs —
+    # see ENG-8259. Do not rely on it.
     warm_future = asyncio.get_running_loop().run_in_executor(None, _warm_litellm)
     warm_future.add_done_callback(lambda _future: state.startup.mark("litellm_warmed"))
 

{dreadnode-2.0.44 → dreadnode-2.0.45}/dreadnode/app/server/prompt.py

@@ -38,7 +38,13 @@ def _get_cli_commands() -> str:
     its internals, the CLI section will be omitted from the system prompt.
     """
     try:
-        from dreadnode.app.cli.main import cli
+        from dreadnode.app.cli.main import cli, register_all_commands
+
+        # Subcommands import on demand (ENG-8259), and this listing is built
+        # once per process behind a cache. Under `dreadnode serve` nothing else
+        # would have registered them, so the agent's system prompt would name
+        # only the handful of commands defined in main.py, permanently.
+        register_all_commands()
 
         # Access internal command registry — guarded by try/except
         command_registry = getattr(cli, "_commands", None)

{dreadnode-2.0.44 → dreadnode-2.0.45}/dreadnode/app/tui/app.py

@@ -75,14 +75,24 @@ from dreadnode.app.tui.status_messages import STATUS_READY, STATUS_STARTING
 from dreadnode.app.tui.theme import (
     ACCENT,
     BG,
+    BG_LIGHT,
+    BG_LIGHTER,
+    BORDER,
+    BORDER_LIGHT,
     BRAND,
+    CODE,
+    CODE_BG,
     ERROR,
     FG,
     FG_FAINTEST,
     FG_MUTED,
     FG_SUBTLE,
     INFO,
+    IS_LIGHT,
+    LINK,
+    PURPLE,
     SUCCESS,
+    TEAL,
     WARNING,
 )
 from dreadnode.app.tui.turn_lifecycle import TurnLifecycle
@@ -1731,11 +1741,35 @@ class DreadnodeTextualApp(App[None]):
                 warning=WARNING,
                 error=ERROR,
                 success=SUCCESS,
-                dark=True,
+                dark=not IS_LIGHT,
                 background=BG,
                 surface=BG,
-                panel=BG,
+                # $panel is the raised tier Textual paints its own widgets on
+                # (DataTable headers, tooltips, collapsibles). Dark flattens it
+                # onto BG; light needs the real step up, because BG there is
+                # pure white and the surface would otherwise disappear.
+                panel=BG_LIGHT if IS_LIGHT else BG,
                 variables={
+                    "dn-bg": BG,
+                    "dn-bg-light": BG_LIGHT,
+                    "dn-bg-lighter": BG_LIGHTER,
+                    "dn-fg": FG,
+                    "dn-fg-subtle": FG_SUBTLE,
+                    "dn-fg-muted": FG_MUTED,
+                    "dn-fg-faintest": FG_FAINTEST,
+                    "dn-border": BORDER,
+                    "dn-border-light": BORDER_LIGHT,
+                    "dn-code": CODE,
+                    "dn-code-bg": CODE_BG,
+                    "dn-link": LINK,
+                    "dn-info": INFO,
+                    "dn-success": SUCCESS,
+                    "dn-warning": WARNING,
+                    "dn-error": ERROR,
+                    "dn-brand": BRAND,
+                    "dn-accent": ACCENT,
+                    "dn-purple": PURPLE,
+                    "dn-teal": TEAL,
                     # Calm markdown headers — avoid primary orange bleeding in.
                     # H1-H4 share $fg so headings read against $fg-subtle body
                     # copy; H5/H6 step down to $fg-muted.

{dreadnode-2.0.44 → dreadnode-2.0.45}/dreadnode/app/tui/dreadnode.tcss

@@ -1,4 +1,4 @@
-/* Dreadnode TUI — minimal dark theme
+/* Dreadnode TUI — minimal theme, dark by default
  *
  * Design principles:
  *   1. Content is king — full width for conversation
@@ -7,41 +7,44 @@
  *   4. Minimal chrome — one status line, no sidebar, no hotkey bar
  *   5. Clear hierarchy — bullets + whitespace over bordered panels
  *   6. Quiet confidence — subtle indicators, not flashy gradients
+ *
+ * Every variable below aliases a `$dn-*` theme variable that app.py feeds from
+ * theme.py, which resolves the dark or light value. Edit the palette there;
+ * a literal hex here would be correct for only one theme.
  */
 
-$bg: #17191c;
-$bg-light: #1f2226;
-$bg-lighter: #292c31;
-
-$fg: #f2f7fc;
-$fg-subtle: #c2c7cc;
-$fg-muted: #95999e;
-$fg-faintest: #696d72;
-
-/* Inline code + fenced blocks: near-white text on a raised background "pill".
- * The pill carries the "code" affordance; tune $code / $code-bg to restyle all
- * code. Aliased to the palette by design; set to a literal hex to diverge.
- * Keep in sync with CODE / CODE_BG in theme.py. */
-$code: $fg;
-$code-bg: $bg-light;
-
-/* Links: near-white + underline (the underline is the affordance). Warm accent
- * is reserved for tool calls. Keep in sync with LINK in theme.py. */
-$link: $fg;
-
-$border: #2b343f;
-$border-light: #434a55;
-
-$info: #4689bf;
-$success: #68c147;
-$warning: #c8ac4a;
-$error: #e44f4f;
-
-/* Extended palette — keep in sync with theme.py */
-$brand: #ca5e44;
-$accent: #ef562f;
-$purple: #a650fb;
-$teal: #20dfc8;
+$bg: $dn-bg;
+$bg-light: $dn-bg-light;
+$bg-lighter: $dn-bg-lighter;
+
+$fg: $dn-fg;
+$fg-subtle: $dn-fg-subtle;
+$fg-muted: $dn-fg-muted;
+$fg-faintest: $dn-fg-faintest;
+
+/* Inline code + fenced blocks: prose-colored text on a raised background
+ * "pill". The pill carries the "code" affordance; tune CODE / CODE_BG in
+ * theme.py to restyle all code. */
+$code: $dn-code;
+$code-bg: $dn-code-bg;
+
+/* Links: always underlined, colored by LINK in theme.py. Warm accent is
+ * reserved for tool calls. */
+$link: $dn-link;
+
+$border: $dn-border;
+$border-light: $dn-border-light;
+
+$info: $dn-info;
+$success: $dn-success;
+$warning: $dn-warning;
+$error: $dn-error;
+
+/* Extended palette — platform screens, data visualization */
+$brand: $dn-brand;
+$accent: $dn-accent;
+$purple: $dn-purple;
+$teal: $dn-teal;
 
 Screen {
     background: $bg;

{dreadnode-2.0.44 → dreadnode-2.0.45}/dreadnode/app/tui/screens/raw_spans.py

@@ -17,7 +17,7 @@ from textual.widgets import DataTable, Static
 
 from dreadnode.app.tui.screens.base import DreadnodeScreen
 from dreadnode.app.tui.spans_reader import RawSpansReader, SpanLineSummary
-from dreadnode.app.tui.theme import FG, FG_FAINTEST, FG_MUTED, FG_SUBTLE, WARNING
+from dreadnode.app.tui.theme import FG, FG_FAINTEST, FG_MUTED, FG_SUBTLE, SYNTAX_THEME, WARNING
 
 if t.TYPE_CHECKING:
     from pathlib import Path
@@ -185,6 +185,6 @@ class RawSpansScreen(DreadnodeScreen):
         renderable = Group(
             self._detail_header(summary),
             Text(""),
-            Syntax(payload, "json", theme="ansi_dark", word_wrap=True),
+            Syntax(payload, "json", theme=SYNTAX_THEME, word_wrap=True),
         )
         self.query_one("#raw-spans-detail", Static).update(renderable)