dreadnode 2.0.44__py3-none-any.whl → 2.0.45__py3-none-any.whl

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/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/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/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/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/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/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/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)

dreadnode/app/tui/theme.py

@@ -8,48 +8,71 @@ The palette is aligned with the variables in `dreadnode.tcss`.
 
 from __future__ import annotations
 
+import os
+
 # --- Color Palette -----------------------------------------------------------
-# Single source of truth.  When changing values here, also update the matching
-# CSS variables in dreadnode.tcss (they cannot be auto-generated).
-
-BG = "#17191c"
-BG_LIGHT = "#1f2226"
-BG_LIGHTER = "#292c31"
-
-# Foreground ramp — even ~17 L* steps (perceptual lightness) on the dark BG so
-# each tier is equally distinguishable; all clear WCAG AA. FG is a crisp, faintly
-# cool near-white (L*97); the tail stays quiet for secondary/faint roles.
-FG = "#f2f7fc"
-FG_SUBTLE = "#c2c7cc"
-FG_MUTED = "#95999e"
-FG_FAINTEST = "#696d72"
-
-# Inline `code` and fenced blocks — near-white text on a raised background
+# Single source of truth for both render paths. `dreadnode.tcss` declares its
+# `$` variables as aliases of the `$dn-*` theme variables that `app.py` feeds
+# from the constants below, so a value changed here reaches the stylesheet on
+# its own. Never write a literal hex into the stylesheet — it would be correct
+# for only one theme.
+
+
+def _is_light() -> bool:
+    """Whether ``DREADNODE_TUI_THEME`` selects the light palette.
+
+    Any other value — unset, misspelled, or explicitly ``dark`` — selects dark.
+    """
+    return os.environ.get("DREADNODE_TUI_THEME", "dark").strip().lower() == "light"
+
+
+# Read once at import. The palette is baked into the module constants below and
+# into the Textual theme registered at app start, so it cannot change without
+# restarting the process.
+IS_LIGHT = _is_light()
+
+BG = "#ffffff" if IS_LIGHT else "#17191c"
+BG_LIGHT = "#f4f5f7" if IS_LIGHT else "#1f2226"
+BG_LIGHTER = "#e8eaed" if IS_LIGHT else "#292c31"
+
+# Foreground ramp — four tiers walking away from the background in even ~17 L*
+# (perceptual lightness) steps, so each tier is equally distinguishable. Dark
+# starts at a crisp, faintly cool near-white (L*97) and steps down; light
+# mirrors that spacing upward from near-black. The top three tiers clear WCAG
+# AA against BG in both themes; FG_FAINTEST is the quiet tail at roughly 3:1.
+FG = "#1f2328" if IS_LIGHT else "#f2f7fc"
+FG_SUBTLE = "#57606a" if IS_LIGHT else "#c2c7cc"
+FG_MUTED = "#6e7781" if IS_LIGHT else "#95999e"
+FG_FAINTEST = "#8c959f" if IS_LIGHT else "#696d72"
+
+# Inline `code` and fenced blocks — prose-colored text on a raised background
 # "pill". The pill carries the "this is code" affordance, so the text stays in
 # the prose family instead of a saturated accent (which is reserved for tool
 # calls). Aliased to the palette by design; set to a literal hex to diverge.
-# Keep in sync with $code / $code-bg in dreadnode.tcss.
 CODE = FG
 CODE_BG = BG_LIGHT
 
-# Links — near-white text; the underline carries the affordance. Warm accent is
-# reserved for tool calls, so links stay quiet and hover to $accent.
-# Keep in sync with $link in dreadnode.tcss.
-LINK = FG
+# Links — always underlined. Dark keeps them in the prose family so the
+# underline alone carries the affordance; light needs a conventional blue,
+# because near-black on white is indistinguishable from body copy. Warm accent
+# is reserved for tool calls, so links stay quiet and hover to $accent.
+LINK = "#0969da" if IS_LIGHT else FG
 
-BORDER = "#2b343f"
-BORDER_LIGHT = "#434a55"
+BORDER = "#d0d7de" if IS_LIGHT else "#2b343f"
+BORDER_LIGHT = "#afb8c1" if IS_LIGHT else "#434a55"
 
-INFO = "#4689bf"
-SUCCESS = "#68c147"
-WARNING = "#c8ac4a"
-ERROR = "#e44f4f"
+INFO = "#0969da" if IS_LIGHT else "#4689bf"
+SUCCESS = "#1a7f37" if IS_LIGHT else "#68c147"
+WARNING = "#9a6700" if IS_LIGHT else "#c8ac4a"
+ERROR = "#cf222e" if IS_LIGHT else "#e44f4f"
 
 # Extended palette — platform screens, data visualization
-BRAND = "#ca5e44"
-ACCENT = "#ef562f"
-PURPLE = "#a650fb"
-TEAL = "#20dfc8"
+BRAND = "#bc4c34" if IS_LIGHT else "#ca5e44"
+ACCENT = "#cf4b2f" if IS_LIGHT else "#ef562f"
+PURPLE = "#8250df" if IS_LIGHT else "#a650fb"
+TEAL = "#0b7d75" if IS_LIGHT else "#20dfc8"
+
+SYNTAX_THEME = "default" if IS_LIGHT else "monokai"
 
 
 # --- Graphic (paste new art here; wordmark is auto-composed to the right) ---

dreadnode/app/tui/widgets/tool.py

@@ -31,6 +31,7 @@ from dreadnode.app.tui.theme import (
     FG_MUTED,
     FG_SUBTLE,
     LINK,
+    SYNTAX_THEME,
     WARNING,
 )
 
@@ -208,7 +209,7 @@ class ThemedMarkdown(Markdown):
     def __init__(
         self,
         markup: str,
-        code_theme: str = "monokai",
+        code_theme: str = SYNTAX_THEME,
         justify: JustifyMethod | None = None,
         style: str | Style = "none",
         hyperlinks: bool = True,

dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-cli/references/cli/evaluation.md

@@ -48,7 +48,7 @@ Builds the evaluation request from CLI flags, an evaluation.yaml manifest (`--fi
 * `--concurrency` — Maximum concurrent evaluation samples.
 * `--task-timeout-sec` — Timeout per task in seconds.
 * `--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. *\[choices: always, on\_success]*
+* `--cleanup-policy` — Sandbox cleanup policy. Hosted E2B evaluations support only `always`; `on_success` is available on Docker and OpenSandbox deployments. *\[choices: always, on\_success]*
 * `--judge-model` — Override the judge model for all tasks in this evaluation.
 * `--env-model` — Override a task ENVIRONMENT (defender) model by role: ROLE=MODEL\_ID (e.g. —env-model blue=dn/claude-sonnet-4-6, repeatable). Distinct from —model (solver) and —judge-model. The role must be declared overridable in the task’s models map.
 * `--egress` — Additional outbound destination for this run’s sandboxes (e.g. —egress staging.example.com, —egress ‘\*.internal.corp’, —egress 10.20.0.0/16; repeatable). Targets union with the task’s own egress.allow and are checked against the deployment’s egress floor identically, so they grant no reach a task declaration could not. Supplying any target makes this run a declaration, restricting it to what is named plus the platform destinations the platform derives.
@@ -200,9 +200,9 @@ Terminal window
 $ dn evaluation retry <evaluation-id>
 ```
 
-Retry failed and errored samples in an evaluation.
+Retry failed samples in an evaluation.
 
-Resets samples that ended in failed, timed\_out, or infra\_error back to queued so they are picked up by workers again.
+Resets samples that ended in failed, timed\_out, cancelled, or infra\_error back to queued so they are picked up by workers again. Samples whose judge errored are not requeued: rerunning the agent would produce a different trajectory.
 
 **Options**
 

dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/runtimes/configuration.md

@@ -122,13 +122,12 @@ resources:
 
 sandbox:
   timeout_seconds: 1800
-  workspace_mount: true
   exposed_ports:
     - 8080
     - 9229
 ```
 
-`cpu_cores` and `memory_mb` size the provider instance. `workspace_mount` controls whether your project workspace is mounted read-write. `exposed_ports` lists ports the platform should surface for host-side access. Defaults and valid ranges are in the [manifest reference](./manifest-reference.md).
+`cpu_cores` and `memory_mb` size the provider instance. `exposed_ports` lists ports the platform should surface for host-side access. The deprecated `workspace_mount` field is accepted for existing manifests but ignored; the sandbox workspace is always a local directory. Defaults and valid ranges are in the [manifest reference](./manifest-reference.md).
 
 ## Outbound network scope
 
@@ -207,7 +206,6 @@ resources:
 
 sandbox:
   timeout_seconds: 1800
-  workspace_mount: true
   exposed_ports:
     - 8080
 

dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/runtimes/manifest-reference.md

@@ -89,7 +89,7 @@ The CLI resolves `selectors` into `secret_ids` before submitting the manifest. S
 | Field             | Type         | Default | Notes                                                                                                                      |
 | ----------------- | ------------ | ------- | -------------------------------------------------------------------------------------------------------------------------- |
 | `timeout_seconds` | integer      | none    | Sandbox expiry in seconds. Minimum 60, capped by your organization’s sandbox runtime limit. Omit for the platform default. |
-| `workspace_mount` | boolean      | `true`  | Mount the project workspace into the sandbox.                                                                              |
+| `workspace_mount` | boolean      | `true`  | **Deprecated.** Accepted for existing manifests but ignored; the sandbox workspace is local.                               |
 | `exposed_ports`   | list of ints | `[]`    | Ports to expose for host-side access. Must be 1–65535. Deduplicated and sorted.                                            |
 | `egress`          | object       | none    | Outbound scope for this runtime’s sandbox. Omitted and empty differ. See below.                                            |
 
@@ -155,7 +155,6 @@ resources:
 
 sandbox:
   timeout_seconds: 1800
-  workspace_mount: true
   exposed_ports:
     - 8080
     - 9229

dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/sandboxes/isolation.md

@@ -7,7 +7,7 @@
 
 > How sandboxes isolate workloads, how to scope what an agent can reach on the network, and which controls remain yours.
 
-An agent in one hosted sandbox cannot read the memory, processes, or local filesystem of another sandbox. It can still make network requests to public services, including services exposed by another sandbox.
+An agent in one hosted sandbox cannot read the memory, processes, or local filesystem of another sandbox. Standalone and interactive sandboxes can still make network requests to public services. Evaluation sandboxes use a narrower network boundary described below.
 
 This distinction matters when you run untrusted agent code: **compute isolation does not imply network isolation.**
 
@@ -17,34 +17,67 @@ Dreadnode runs each hosted sandbox in a separate E2B Firecracker microVM. Each m
 
 Agents may have broad privileges inside their own sandbox. They can run arbitrary commands, install packages, and modify local files. Those privileges stop at the microVM boundary.
 
-| Resource                | Isolated between sandboxes? | Enforcement                                                  |
-| ----------------------- | --------------------------- | ------------------------------------------------------------ |
-| Memory and processes    | Yes                         | Firecracker microVM                                          |
-| Local filesystem        | Yes                         | Separate microVM storage                                     |
-| E2B project API         | Yes                         | The E2B project API key stays in the Dreadnode control plane |
-| Dreadnode runtime API   | Yes                         | A bearer credential scoped to one sandbox                    |
-| Public network services | No                          | Each service must authenticate its callers                   |
-| Outbound network        | Governed by policy          | An egress policy composed per sandbox — see below            |
+| Resource                 | Isolated between sandboxes? | Enforcement                                                  |
+| ------------------------ | --------------------------- | ------------------------------------------------------------ |
+| Memory and processes     | Yes                         | Firecracker microVM                                          |
+| Local filesystem         | Yes                         | Separate microVM storage                                     |
+| E2B project API          | Yes                         | The E2B project API key stays in the Dreadnode control plane |
+| Dreadnode runtime API    | Yes                         | A bearer credential scoped to one sandbox                    |
+| Evaluation task services | Yes                         | Restricted E2B ingress and paired-runtime egress rules       |
+| Public network services  | No                          | Each service must authenticate its callers                   |
+| Outbound network         | Governed by policy          | An egress policy composed per sandbox — see below            |
 
-Evaluation agents and task environments also run in separate sandboxes. The agent cannot inspect the task environment’s files or processes. Dreadnode gives the agent only the public URLs declared by the task so it can interact with the intended services.
+Evaluation agents and task environments also run in separate sandboxes. Dreadnode restricts each task environment’s public ingress and configures its paired runtime to reach only declared task service hosts plus the platform and model gateway. E2B adds the task sandbox’s traffic credential only when the paired runtime calls those exact hosts, including HTTP and WebSocket services.
+
+```
+flowchart LR
+  Anonymous["Anonymous caller"]
+  API["Dreadnode API"]
+  Gateway["Model gateway"]
+  Internet["Other public hosts"]
+
+  subgraph Pair["E2B evaluation pair"]
+    direction LR
+    Runtime["Agent runtime sandbox<br/>deny-all egress"]
+    Task["Task sandbox<br/>traffic-token ingress"]
+  end
+
+  Anonymous -. "blocked" .-> Task
+  Runtime -->|"declared host + token header"| Task
+  Runtime -->|"allowlisted"| API
+  Runtime -->|"allowlisted"| Gateway
+  Runtime -. "blocked" .-> Internet
+
+  classDef sandbox fill:#171124,stroke:#a78bfa,color:#ececf0,stroke-width:2px
+  classDef allowed fill:#102018,stroke:#34d399,color:#d5ffe2,stroke-width:2px
+  classDef blocked fill:#2a0b10,stroke:#d40924,color:#ffd6d6,stroke-width:2px
+  class Runtime,Task sandbox
+  class API,Gateway allowed
+  class Anonymous,Internet blocked
+  style Pair fill:#08080b,stroke:#26262c,color:#ececf0
+  linkStyle 0,4 stroke:#d40924,stroke-width:2px
+  linkStyle 1,2,3 stroke:#34d399,stroke-width:2px
+```
+
+Only the paired agent runtime gets deny-all egress by default. The task sandbox’s outbound traffic follows its egress declaration when present; otherwise it follows E2B defaults.
 
 ## Access to another sandbox
 
 A sandbox cannot enumerate or manage other sandboxes through the E2B project API because Dreadnode does not inject its E2B project API key into agent workloads. Dreadnode also checks the requesting user’s organization, workspace access, and sandbox ownership before allowing sandbox operations through the platform API.
 
-Network services are a separate boundary. E2B assigns public URLs to services running inside a sandbox. By default, anyone who knows one of these URLs can send requests to it.
+Network services are a separate boundary. E2B assigns public URLs to services running inside a sandbox. By default, anyone who knows one of these URLs can send requests to it. Evaluation task sandboxes disable that default: anonymous requests fail, and E2B adds the provider traffic credential only when the paired runtime calls ports declared by the task.
 
-Dreadnode’s agent runtime API requires a bearer credential scoped to one sandbox. Only the sandbox owner can obtain it, and every client they attach presents the same value. Services supplied by a task, such as a web application or API under test, define their own authentication. If a task service has no authentication, another sandbox or internet client that learns its URL can request it.
+Dreadnode’s agent runtime API requires a bearer credential scoped to one sandbox. Only the sandbox owner can obtain it, and every client they attach presents the same value. Services supplied by a task, such as a web application or API under test, define their own authentication when used outside an evaluation pair.
 
 Sandbox isolation is not service authentication
 
-Treat every service exposed from a sandbox as internet-reachable. Add authentication inside the service when it handles sensitive data or actions.
+Treat services exposed from standalone or interactive sandboxes as internet-reachable. Evaluation pairing does not change those workloads.
 
-E2B supports traffic access tokens for restricting public sandbox URLs. Dreadnode does not currently expose this as a customer-configurable setting. See E2B’s [public access controls](https://docs.e2b.dev/network/restrict-public-access.md) for the provider capability.
+Dreadnode applies E2B traffic access tokens internally to evaluation task sandboxes. This control is not customer-configurable. See E2B’s [public access controls](https://docs.e2b.dev/network/restrict-public-access.md) for the provider capability.
 
 ## Internet and private networks
 
-By default an agent reaches the public internet. It can download packages, clone repositories, call public APIs, and send data to external hosts.
+By default an agent reaches the public internet. It can download packages, clone repositories, call public APIs, and send data to external hosts. Evaluation runtimes instead use deny-all egress with exact allowances for their task services, the Dreadnode API, and the model gateway.
 
 Hosted sandboxes additionally have private and link-local ranges blocked at E2B’s network edge — `10.0.0.0/8`, `100.64.0.0/10`, `127.0.0.0/8`, `169.254.0.0/16`, `172.16.0.0/12`, and `192.168.0.0/16` — which keeps agents off common private-network and cloud metadata addresses. It restricts no public destination.
 
@@ -157,17 +190,17 @@ On hosted sandboxes, enforcement rides the sandbox create call and is always in
 
 Dreadnode limits the credentials available inside each sandbox:
 
-| Credential or data           | Control                                                                     |
-| ---------------------------- | --------------------------------------------------------------------------- |
-| E2B project API key          | Held by the Dreadnode API and never injected into agent sandboxes           |
-| Evaluation and job API keys  | Restricted to the platform scopes required by that workload                 |
-| Interactive runtime API keys | Follow the initiating user’s platform permissions                           |
-| Runtime bearer credential    | Unique to one sandbox; required by the Dreadnode runtime API                |
-| Workspace storage            | Uses temporary credentials limited to one organization and workspace prefix |
-| Model gateway key            | Limited to permitted models, expires, and cleanup requests revocation       |
-| User secrets                 | Injected only when selected for the workload                                |
-
-Processes inside a sandbox can read credentials and secrets injected into that sandbox. Wherever public egress remains available, compromised or malicious code can send those values to an external host. Inject only the secrets the workload needs, use the narrowest permissions available, and declare an egress scope when the workload’s destinations are knowable — it bounds where a leaked secret can go.
+| Credential or data           | Control                                                                                     |
+| ---------------------------- | ------------------------------------------------------------------------------------------- |
+| E2B project API key          | Held by the Dreadnode API and never injected into agent sandboxes                           |
+| Evaluation and job API keys  | Restricted to the platform scopes required by that workload                                 |
+| Interactive runtime API keys | Follow the initiating user’s platform permissions                                           |
+| Runtime bearer credential    | Unique to one sandbox; required by the Dreadnode runtime API                                |
+| SDK remote storage           | Fetches temporary workspace-scoped credentials on demand; provisioning does not inject them |
+| Model gateway key            | Limited to permitted models, expires, and cleanup requests revocation                       |
+| User secrets                 | Injected only when selected for the workload                                                |
+
+Processes inside a sandbox can read credentials and secrets injected into that sandbox. A paired evaluation runtime can send them only to its allowlisted hosts. Wherever public egress remains available, compromised or malicious code can send those values to an external host. Inject only the secrets the workload needs, use the narrowest permissions available, and declare an egress scope when the workload’s destinations are knowable — it bounds where a leaked secret can go.
 
 ## Lifetime and audit trail
 

dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/tui/local-storage.md

@@ -7,7 +7,7 @@
 
 > Every file Dreadnode writes under ~/.dreadnode/ — config, profiles, transcripts, spans, caches, and auth tokens.
 
-Dreadnode keeps all local state under `~/.dreadnode/`. Nothing ships to the platform that isn’t explicitly sent; nothing sensitive sits outside this directory. Back it up and you back up every session, every profile, every cached artifact.
+Dreadnode keeps its local state under `~/.dreadnode/`. Managed sessions also sync the state needed by the platform, while credentials and local caches remain in this directory. Back it up and you back up every local session, profile, and cached artifact.
 
 ```
 ~/.dreadnode/
@@ -69,8 +69,8 @@ Caution
 
 Don’t check `~/.dreadnode/` into version control. `config.yaml` and `mcp-auth.json` contain credentials.
 
-## Sandbox mount
+## Storage in managed sandboxes
 
-When a Dreadnode-managed sandbox runs, `~/.dreadnode/` inside the sandbox is mounted via `s3fs` to the workspace’s storage bucket — scoped to `{org_id}/workspaces/{workspace_id}/`. Writes from the sandbox land in the same logical tree, but the physical storage is the platform, not the sandbox’s disk.
+Inside a Dreadnode-managed sandbox, `~/.dreadnode/` and `/home/user/workspace` are local to that sandbox. They are not object-storage mounts. Pausing and resuming an E2B sandbox preserves its local filesystem because it resumes the same sandbox.
 
-This is what lets a session’s transcripts and artifacts survive when the sandbox is reset or replaced.
+Resetting, replacing, or deleting a sandbox discards files that were not synced elsewhere. Managed session state is synchronized through the platform API, and SDK remote-storage operations access object storage explicitly.

dreadnode/core/tls.py

@@ -41,7 +41,7 @@ _GENERATED_MARKER = "# dreadnode-generated trust bundle (system + operator CA)"
 #   CURL_CA_BUNDLE ............... curl
 #   GIT_SSL_CAINFO ............... git
 #   NODE_EXTRA_CA_CERTS .......... Node, Bun, Claude Code CLI, agent-browser
-#   AWS_CA_BUNDLE ................ botocore, s3fs, mount-s3
+#   AWS_CA_BUNDLE ................ botocore, Python s3fs
 #   GRPC_DEFAULT_SSL_ROOTS_FILE_PATH ... the OTLP span exporter
 TRUST_FILE_ENV_VARS: tuple[str, ...] = (
     "SSL_CERT_FILE",

dreadnode/storage/storage.py

@@ -68,8 +68,9 @@ class Storage:
           job.json                    ← terminal-only frontier hashes
     ```
 
-    When running in a sandbox, ~/.dreadnode is mounted via s3fs to the user's
-    workspace storage, with the S3 prefix already scoped to {org_id}/workspaces/{workspace_id}.
+    Remote operations use an fsspec-compatible object-storage client. In a
+    managed sandbox, the local cache remains on the sandbox filesystem; it is
+    not an object-storage mount.
     """
 
     def __init__(
@@ -419,7 +420,7 @@ class Storage:
         return self.cas_path / algo / hash_val[:2] / hash_val[2:4] / hash_val
 
     def remote_blob_path(self, oid: str) -> str:
-        """Remote path for blob (includes bucket for s3fs)."""
+        """Remote path for blob, including the provider bucket."""
         algo, hash_val = oid.split(":", 1)
         bucket = self._credentials.bucket if self._credentials else "user-data"
         return f"{bucket}/{self.remote_prefix}/cas/{algo}/{hash_val[:2]}/{hash_val[2:4]}/{hash_val}"

{dreadnode-2.0.44.dist-info → dreadnode-2.0.45.dist-info}/METADATA

@@ -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.dist-info → dreadnode-2.0.45.dist-info}/RECORD

@@ -29,7 +29,7 @@ dreadnode/agents/mcp/client.py,sha256=13sEJhLDfk1lPeTXfOsoc2j_akX1WX4rc4PSp_Cw36
 dreadnode/agents/mcp/config.py,sha256=hBROQZqUF4Y9wI6aLpYc5wHjneIA593PjfHDO1voAN0,2433
 dreadnode/agents/mcp/server.py,sha256=LyEgY7xvAwMZG3ioMUwfPsP0zSAlKeXtgU2XearDx_0,3358
 dreadnode/airt/__init__.py,sha256=VMUzuBuzQdsKYkPs5OLyINCgfLX9Rrr0XQpObEYofp8,10589
-dreadnode/airt/_base.py,sha256=avHEpRPaa1GzCWBXD6YPtXuZ0iPzTDrjzcPDhiS8QaU,8476
+dreadnode/airt/_base.py,sha256=qb2jsTOsDtwZg7u5DndyjGSYZLsE8pAlQ7cLuj9QJYg,11567
 dreadnode/airt/adversarial_reasoning.py,sha256=pDTIDIHRF_DL0YjEGmSeEtPGKCltjuFlAEIFlKOqqmU,13630
 dreadnode/airt/advpromptier.py,sha256=TJPPUdUTJu2nnY5VJKNapzDcClBHI49yU9HSSV4R2Ik,10062
 dreadnode/airt/agent_suite.py,sha256=alR7iuUi9Pa2HH9p8OdbMj-bkGFHrnqcr-slVx-_Rao,8180
@@ -203,10 +203,10 @@ dreadnode/app/cli/args.py,sha256=MSHhdpCHfhvlSYfP6tEyPnNBH9i_TkEbvpV8RZ8vrs4,874
 dreadnode/app/cli/capability.py,sha256=H4sowggKHKw1HRkFP3OzHOYPy6n1yKraiAGO8rSfvos,56034
 dreadnode/app/cli/dataset.py,sha256=cv5xNxBO0SihNmQauLJxIpZzNFl1sKxP8GIRKmCulwI,14023
 dreadnode/app/cli/environment.py,sha256=Slm_4d9VuzbhuzC3Pino2n5C6orKG7riT4E58Lx-5v8,17054
-dreadnode/app/cli/evaluation.py,sha256=mlkwGuHZPZ7M4tA2WeYIlooqiSLtW5p1E0Rk3KA203A,68911
+dreadnode/app/cli/evaluation.py,sha256=rUTGwBTBZG-Prh5PzK2-hbceCV4Tk3dj_5mRUxstA98,69050
 dreadnode/app/cli/inference_model.py,sha256=W9zxwlspvSr2r1MoaTCuY8K2wEoedugPdhZHKq1_QfM,4707
 dreadnode/app/cli/judge.py,sha256=aqI5jL4xhCti9ZJmZ14ihhDgKj_RJsfiG5WjhllVJnU,15864
-dreadnode/app/cli/main.py,sha256=u7n5ukMcEmPNgfuI26ltS9TlcmorJuE0VwPx-XfOIbI,22002
+dreadnode/app/cli/main.py,sha256=ObfPdqZcL58KK_aOSdVnNLKQIGrG5A9ONzACHTTRS8Y,26964
 dreadnode/app/cli/model.py,sha256=A4kWIRLWm26B296McNWM1WEpDqCFGoxgOirCoNy66Tw,17372
 dreadnode/app/cli/optimize.py,sha256=qQ8YnNFG3CCgrqZw4MiS9d_8BOsTwIjw7WtqDapcqPU,22788
 dreadnode/app/cli/runtime.py,sha256=MOtCGndZ5QivE3LKgkhUriVMk2ma-wiVqOszPGUZl_8,37348
@@ -235,11 +235,11 @@ dreadnode/app/client/models.py,sha256=TbzXwrpoog3oGWpgbpZ2-JoTaxBuSQx1DDh4GSpsfb
 dreadnode/app/client/runtime_client.py,sha256=KXX-z1PjNm-2GCapoVPpUz--aLAA2Piu03Ykj_lHRlY,55714
 dreadnode/app/client/transports.py,sha256=SOUX_tMNhoMPPNnk_6HRoyPNGeeDMn1KhnrdlS2d304,15921
 dreadnode/app/server/__init__.py,sha256=fub75X9MOi9mK_-vFPD03rNMC04gYsNkecVSPbsI4Ic,187
-dreadnode/app/server/app.py,sha256=vsg-g7mDj5QfZhkI_-Bj4h-1oZtxoJ4LSafzTzyg510,216918
+dreadnode/app/server/app.py,sha256=u1nG7X8VOrohd6uI0u4YhVoyDiMVsH-5j-gXU4irQaI,218039
 dreadnode/app/server/auth.py,sha256=LVQ6lgSc74Y3sWRGM2pf6Xgp2n7c6oWQZZPJ6k6PjnY,4440
 dreadnode/app/server/capability_manager.py,sha256=91FJYQ8RIQAkRRFCoCnUbQc89Y0ghSOAJ3-PGVaJUv4,52428
 dreadnode/app/server/model_resolution.py,sha256=LwahZgnaToC6kOePylLJCzCN1ajTj47YxIceo2syAa4,4735
-dreadnode/app/server/prompt.py,sha256=Xg2NfT3ymGJHb0m1YuK4NJejOpQkYfdIXX-RAdY_CyE,12255
+dreadnode/app/server/prompt.py,sha256=_1Q9G8i-KlfNnApK4mK_2_nqrMDOZb0-49vS0kaS1GY,12618
 dreadnode/app/server/prompt_registry.py,sha256=tap9N9vAzQk0BHhECCHr3JKrLX3oMhzF14X4rH-Rur4,6805
 dreadnode/app/server/runtime_credentials.py,sha256=Zo0EfulHxTSycOhoYE4O0gKXwMdCKCMSyn1RkfEB_FY,11744
 dreadnode/app/server/runtime_events.py,sha256=a4b2iuKjJaly2pcDxVs7wHXZ2uHe1snSW3H0lS4k9pg,17792
@@ -251,14 +251,14 @@ dreadnode/app/server/websocket.py,sha256=PEUI5gYofWW-t5sQd-DvKps6ezD9tSFSWDG_6MR
 dreadnode/app/server/worker_manager.py,sha256=krmTM_asIp3SB91iuD3DlrQm0S62k9LMh-igDG1kyAI,28219
 dreadnode/app/server/ws_auth.py,sha256=n1Bo91yM6IFQHNZy3j-r6RiCjzA44205q9cQxf9_iLU,3991
 dreadnode/app/tui/__init__.py,sha256=DwG6Q1FhmmFcxQ75ziJFjj940dtPeR3J6rilSCOe5WE,64
-dreadnode/app/tui/app.py,sha256=eppjlolR3mLiW4t6mqOg_8FYiUvOX-FmH3BmbxO3Hw8,198695
+dreadnode/app/tui/app.py,sha256=4K9UCIP7Mp9wIj5CklbGmyeCC5aOYeQKPGCAIUr10aI,199999
 dreadnode/app/tui/auth_flow.py,sha256=ufU7c9lmGUc80ewzw9CJo8riahQjqAt2pKjccH39-74,6872
 dreadnode/app/tui/bug_report.py,sha256=AtfFhdeddnvA8OtCFBd90U2TVAwH2nlKYm3X6cbwMcY,17696
 dreadnode/app/tui/capabilities_manager.py,sha256=bft9Q2tvDkFQQBuqAfVYfrC-VZ2_tbi2vUBYZRXZLzg,22231
 dreadnode/app/tui/command_dispatcher.py,sha256=zO8Rwa4-96ySO5h1s3hwLiGf68CYl22jjOQgBt_H9ag,32942
 dreadnode/app/tui/commands.py,sha256=PwLg5CdNoaEJwI27HIw5nlfqsdfpSyjf9HSya5aChfA,4085
 dreadnode/app/tui/connection.py,sha256=Ca4tXPOjjYxM5eIjTgXQTHAqLlOj8vCCFoRYn7KwkL8,12676
-dreadnode/app/tui/dreadnode.tcss,sha256=O0LBXcMhBguB97cL5gSKOFooyAVqvVthL6ZxEJgA88A,19758
+dreadnode/app/tui/dreadnode.tcss,sha256=g-ZAKkACc3ns7IA6yDOZqGozkDToEvAghlxXLQ-bACs,19923
 dreadnode/app/tui/error_handler.py,sha256=qcZLaLgBNbyf540Yl5BYFxcZXBnaeDKI8cB81waOnFU,7074
 dreadnode/app/tui/model_manager.py,sha256=t0I52eq9ks-mk2ui7Oldn0Cl7jZauJMSqe6EIbfxlZw,36548
 dreadnode/app/tui/model_variants.py,sha256=e8_zTTZLUCtAM_BR8QDDHeV3SswqoFHLBPvThrKSIaE,8835
@@ -267,7 +267,7 @@ dreadnode/app/tui/screen_router.py,sha256=Xn7UKPAt0J2SoXqpFcTiSjwXRd8VM1uzgoG4T2
 dreadnode/app/tui/sessions_manager.py,sha256=nSX7hmzC5Ga9qNYkuho5BV39x4X6_1tUyNAwYoho4sc,91973
 dreadnode/app/tui/spans_reader.py,sha256=0jsdGBsTTt2uektvsyQH1Wl-_uW2blRsamOy9HnXmRg,4201
 dreadnode/app/tui/status_messages.py,sha256=fr4wcNl0VbgsNAQkLGCewMaFpoP1S8IS33w599fYog8,426
-dreadnode/app/tui/theme.py,sha256=h2vNnTF4YQdASKB99MvhOQpMqYpidqdJPWHoJl9lmIA,5617
+dreadnode/app/tui/theme.py,sha256=UQ9diWF-6RhPvrTQJF-bQJBkyXZVWk17xbX8jPRenSQ,7040
 dreadnode/app/tui/tool_format.py,sha256=qdJ0jz0aIL2c6_aRVKXBrfVqWExAhr3kL-BrgJNZfU8,22081
 dreadnode/app/tui/turn_coordinator.py,sha256=JUHs-za7zGLCgWEgt_nf080t-rJ5qK0CH_jPy0fJRaw,26812
 dreadnode/app/tui/turn_lifecycle.py,sha256=K_QnfRccQC9nFEhsMwbS_cq3wz0QMEKJ0O8d7tuvDAc,7716
@@ -285,7 +285,7 @@ dreadnode/app/tui/screens/console.py,sha256=UfSnixGXOkP4w0gPfYMOTu0dYsSy7Ftli9-M
 dreadnode/app/tui/screens/environments.py,sha256=thEKsMXCvD9gSpQS0ScrTAE_wgNsvr6DDYOBnW-Bd5A,18646
 dreadnode/app/tui/screens/evaluations.py,sha256=nlmllhQA2NRPjIie4oCy3wswuUytEoTtRXd-I0Gg2KA,20441
 dreadnode/app/tui/screens/models.py,sha256=u_Dv4W5GhKtLM6YPc8HiYtwNNGlJBAAELRkDac75SgE,38395
-dreadnode/app/tui/screens/raw_spans.py,sha256=JIntXgq7tLIL6w7n1n8XjP3vqEMqFfxUmK7pOmcW7N4,7148
+dreadnode/app/tui/screens/raw_spans.py,sha256=62fq45xUNO1Fsfw6VTS5RVbwOs-Ug9phsek41K0LOMg,7163
 dreadnode/app/tui/screens/readme.py,sha256=wEaBZhTE7FmA6T4MMEeGvxYDIOFfV-SV0K7mPnHK6wU,3684
 dreadnode/app/tui/screens/report_bug.py,sha256=lPs7xsXPwREv8jYY00KQ4wL85C55j1cNEBb8MT9VQ80,16784
 dreadnode/app/tui/screens/runtimes.py,sha256=zBZQ2vFnLmaH_8c9QChQmPJSi7NJ95bnwSDI7WSK_AI,51540
@@ -321,7 +321,7 @@ dreadnode/app/tui/widgets/skills_dialog.py,sha256=ykIPJfquX6eVTScnhyrQiZ2obe2eZB
 dreadnode/app/tui/widgets/slash_overlay.py,sha256=KFNrosL8lmzc3BdJ0kWAKO8ByUTJTmWCFA2jAicCnDQ,3522
 dreadnode/app/tui/widgets/status_bar.py,sha256=eEH4isKvMaVtbIVorPnAS14zXhXkMkiqmfbl5tWoS0I,4799
 dreadnode/app/tui/widgets/throbber.py,sha256=NbgzuL86GgPnNS5P-X07ZanACkqwFksH1ELg-UbVzAs,2428
-dreadnode/app/tui/widgets/tool.py,sha256=dsr2oI6Xs_d1qc0TgvbgHd6w8K6oj49Q1LIaJGtPL2k,25095
+dreadnode/app/tui/widgets/tool.py,sha256=kw0x9ibh9kkQQAIM8sO-F-Y-fgw1dRlnaCeP0SpNQLI,25116
 dreadnode/app/tui/widgets/tool_progress.py,sha256=VYr-vpC5214DgIAxrG8elONbTO1KHbIKYBzpmiCh_TM,3682
 dreadnode/app/tui/widgets/tools_dialog.py,sha256=KvwObbYvT2yRpYXcIpYHR_Jx9Vo3rCAYy_4Solra_y4,2096
 dreadnode/app/tui/widgets/welcome.py,sha256=-XI4BcV1uQBGAGootUGunmU7fb1Krg065zzph23tDM4,15731
@@ -370,7 +370,7 @@ dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-cli/references/cli/air
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-cli/references/cli/capability.md,sha256=SKOsUhcLv_Ou3YKp3oJvN9zp4hsHRJOMJ6aMpwqV03I,10131
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-cli/references/cli/dataset.md,sha256=dUDXFotOLmYjouQu7tKI1GJ0h_bNyHSkyo4mVmvKiTY,4871
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-cli/references/cli/env.md,sha256=rSvZJYykjxREeumyA3656yGMqxI7O6SjcJZGbsPdQXY,4542
-dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-cli/references/cli/evaluation.md,sha256=irCm3NYx_sO6GBvaNnJmCTeRrbYBOYwxPPg7uvhZurc,10901
+dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-cli/references/cli/evaluation.md,sha256=IQ3-GxjOXgMx79MJd5wLzfkDCyz-Ex5olCxQF9yuvro,11115
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-cli/references/cli/inference-model.md,sha256=tyZifFBzlYFXCNkAk2HIFu828mc62LOBRUEuAr_-FBs,1657
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-cli/references/cli/judge.md,sha256=-pX8CtXpAytZWaBekbKR8GUi9qlnCfdl5FyXrwhVrgo,2023
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-cli/references/cli/main.md,sha256=2AG506lKzD7N9Zh5BqqE9U0xO3_A0s9XM2XCihq9ylE,2338
@@ -401,18 +401,18 @@ dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/pl
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/platform/secrets.md,sha256=r2pSuwamAHmg7oasdlad32I2LmBFXCYYxWOeEipsquo,7094
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/platform/settings.md,sha256=lpxTXDWP0_Yq_JS9a3j_CTE7Qn5G00E8-ZaFj6eYshg,11346
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/platform/workspaces.md,sha256=srQeAmPoSnzW0lTAHdioBwbYseW04sKnLULkNePuqCQ,4722
-dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/runtimes/configuration.md,sha256=7DK_0A0UA54NNAorRouuB9GHC_eCPEAH2lVCOPkkcVc,8462
+dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/runtimes/configuration.md,sha256=E-Onx_TN7CfoIIjMsyffQufrXFjgvPXPc-xKAiCEhEQ,8471
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/runtimes/managing.md,sha256=geUNFZ2xNgjVOXqlSyKS0vZxIAQDmcTOmwMZBhE_AdU,8446
-dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/runtimes/manifest-reference.md,sha256=tkbWRd_bGX3CVsjNeeEDlmoUimuf5BrJRrColQqpNd8,10333
+dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/runtimes/manifest-reference.md,sha256=imaGIjpTXAcO7Yrz8eqpLoTz9tOlg0e1g7O8QJz9GO0,10309
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/runtimes/overview.md,sha256=g_zWSUBrLcnzQyq8SyEKPgGBT3GSKigK_sKJtAVEuTA,4447
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/runtimes/quickstart.md,sha256=57MDx0gEI_dtXHCLcCigiQJgwtC4eoEDEPW1cECBgFM,3364
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/runtimes/serve.md,sha256=INt3vyDxpIwRdjKQEH4oaLtKK32VnWMa0D66oqZ56oM,4628
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/sandboxes/environment-lifecycle.md,sha256=SQ4B822MCdBib6L6mrvyCvPWO_3RE1uTiCZAyT8aYmA,5491
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/sandboxes/inspecting.md,sha256=HWyXLphy3JgLR90khcxEvGOc4pGeQ6OGjbwo2bSzMvY,4478
-dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/sandboxes/isolation.md,sha256=sGrTu27Evg51iKvl3Y-jMZbu6D75gfTA9Qedya-sPpg,15592
+dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/sandboxes/isolation.md,sha256=0g1tlPxmSIdSGP_10K4mPinBuEjY_GafShD9fOETkjQ,17503
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/sandboxes/overview.md,sha256=Mwu6cArpkSvDDnMaDVO7XdNSPuifcu_fhLYLAe9mjhk,5847
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/sandboxes/runtime-limits.md,sha256=YWjoUzk2ntRObTVuuT8jC3Cm_N05dv9zydcoO6Xxf2E,2206
-dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/tui/local-storage.md,sha256=yHPpND3_TwvXC9OQT6Ne0mWRoVfX7JfkF6zz-d2Flmw,6256
+dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/tui/local-storage.md,sha256=IZk9FSVzqKNEIQqtZtajIdRReJUc79DW0fLvn07Lo8k,6340
 dreadnode/builtin_capabilities/dreadnode/skills/dreadnode-concepts/references/tui/overview.md,sha256=GL9i-vPrWWKFlPZsH2x5jHqq4YB1Rt83QDQ_NBi-SGM,3048
 dreadnode/builtin_capabilities/dreadnode/skills/getting-started/SKILL.md,sha256=P8Bl8n0-NQZwzfzNy79uUX5ycxZW-XR6gij3GdP-NGE,13030
 dreadnode/builtin_capabilities/dreadnode/skills/research-capabilities/SKILL.md,sha256=Dc-kHc_BDUAaCbFy3UyRbvoM-GF8CX8umIblj2AsApg,4871
@@ -458,7 +458,7 @@ dreadnode/core/startup_clock.py,sha256=aJXDPJYx1WZrl6PFS9JIcoZT1PNDxvxLNEtkFeIAo
 dreadnode/core/stopping.py,sha256=cm4b1hbOT731gZLptLAMzwlO13LmjHc1c-r9lAls8sw,11889
 dreadnode/core/task.py,sha256=FnXjYUBWhxcL5qcLkg79tZv4CtPspvr_aLfXltce92g,32758
 dreadnode/core/templating.py,sha256=djDbkOEQoQNf3FFE7vSEihjVviaPkl6HdAk0ZkoTbY0,4653
-dreadnode/core/tls.py,sha256=NUHSjfBTyjwvKU2PIzAQ99KlQP6Y8HsweTRgAY6M3us,15092
+dreadnode/core/tls.py,sha256=fyqqjfvyuQyfRO1Nhh7PYGv-MiyyZIzyAf1sG0FQggE,15089
 dreadnode/core/transforms.py,sha256=wuJLZzUTr1PzT3tTlOdf4LQvDgk18t20sUYo2TVkaTs,13248
 dreadnode/core/util.py,sha256=z9zxwVcmzOgXzOEVsuEJQKaOnuKukua2MtaJGYz_4oY,22683
 dreadnode/core/meta/__init__.py,sha256=P4kVnPufWQcetysMULq37Ghpwi1FcjwQ-BOE9gI3mHU,1325
@@ -601,7 +601,7 @@ dreadnode/scorers/supply_chain_detection.py,sha256=QyS53yYSPXTiV-lGRJy7G7eJBYbPM
 dreadnode/storage/__init__.py,sha256=4iiLn_vhBqpNlfuTHs1fWY-It-hqJIF7mPUqg_7Dlk4,1201
 dreadnode/storage/providers.py,sha256=BmtHZcfxZRf741k0DFiNmv0zryf5rYs7nGK9jHiAg2Q,7422
 dreadnode/storage/session_store.py,sha256=HZC8l0TJ6I42PwvLKGWLJNBJqvj8UGTYBqhSEpx-0Yc,18498
-dreadnode/storage/storage.py,sha256=WA3YGLc_uOwmE2RdjzhDXKNl9-_DhtOQ_UNOd1jUFls,34104
+dreadnode/storage/storage.py,sha256=Wac7h0n-chy14zSKR_8M8xD0Ni3hhPHkSvb7T4JccvI,34120
 dreadnode/tools/__init__.py,sha256=a3TLVpCFiS2VwvRMN9U_z46SESMxbLOBjpl31Kqev30,4594
 dreadnode/tools/_ripgrep.py,sha256=GVIzsfl6DkFR9GwohIJS1ybi5UiZwD-jjiD0M_tnfmU,1465
 dreadnode/tools/apply_patch.py,sha256=RjzzB2CJ2-9EcBi2iD7qYunzN8hk4amACw7nsBOiFIQ,14880
@@ -736,8 +736,8 @@ dreadnode/transforms/system_prompt_extraction.py,sha256=rtWKibIipr1tmFH3P95UE4W4
 dreadnode/transforms/text.py,sha256=8qEldTVeXblxxCCU31Q2MGx3dccMxESOoSga-Y87Mnk,19923
 dreadnode/transforms/video.py,sha256=pWPSAN3YokvWpYsAOvOVH1d2Zd5JPldl17ICw1532a8,33136
 dreadnode/transforms/xml_tools.py,sha256=Zj2sdvmyCoVLua4XkWnKYFRmS8ZFSWrQ5nunspCqpM4,15057
-dreadnode-2.0.44.dist-info/METADATA,sha256=iyNjHCnxsq76F0YpnX58hzFg--plN5A4aUE96eexK_c,13895
-dreadnode-2.0.44.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-dreadnode-2.0.44.dist-info/entry_points.txt,sha256=LvV-eGt7GlPEHy1YDiClWhr4qbsX_D9l0_QNo0j_XPI,81
-dreadnode-2.0.44.dist-info/licenses/LICENSE,sha256=UMJAkT3OxyPBvOmQ74h_1v8DYFRYIfMfFiaP2lFZCmc,11375
-dreadnode-2.0.44.dist-info/RECORD,,
+dreadnode-2.0.45.dist-info/METADATA,sha256=B2zm-2VUBbZw-RTfYROIRIalGtULTzC-SqQG3gGisgE,13895
+dreadnode-2.0.45.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+dreadnode-2.0.45.dist-info/entry_points.txt,sha256=LvV-eGt7GlPEHy1YDiClWhr4qbsX_D9l0_QNo0j_XPI,81
+dreadnode-2.0.45.dist-info/licenses/LICENSE,sha256=UMJAkT3OxyPBvOmQ74h_1v8DYFRYIfMfFiaP2lFZCmc,11375
+dreadnode-2.0.45.dist-info/RECORD,,