From 62c6ee71abfa280e741b9d15cc12c982d5456073 Mon Sep 17 00:00:00 2001
From: Edgar Arakelyan <edgar.arakelyan@scale.com>
Date: Thu, 5 Nov 2026 14:52:26 -0800
Subject: [PATCH 1/6] feat(run): --set KEY=VALUE sets env keys for one run;
 computer envs take tools

agent-env run --set KEY=VALUE sets a key in every env the bundle's tasks
deploy whose type takes it, or in one env as envs/NAME.KEY=VALUE, the value
TOML or a bare word and the key dotted into tables. The envs it changes,
the envs and tasks naming them and the evals naming those tasks are written
under ids ending in the settings, leaving the bundle as written.

Computer envs take tools = "standard" | "driver" | "both", which a deploy,
and a reset, applies to the agents' role through the driver's tool access.

Refs FD-4362

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/agent_env/bundle/__init__.py           |   2 +
 src/agent_env/bundle/run.py                |  46 +++--
 src/agent_env/bundle/variants.py           | 208 +++++++++++++++++++++
 src/agent_env/cli/run.py                   |  32 +++-
 src/agent_env/computers/README.md          |   2 +
 src/agent_env/drivers/README.md            |   5 +
 src/agent_env/drivers/aliases.toml         |   2 +-
 src/agent_env/env/envs/_deployment.py      |   7 +-
 src/agent_env/env/envs/computer/app_env.py |   5 +-
 src/agent_env/env/envs/computer/env.py     |  57 ++++--
 tst/unit/bundle/installed_test.py          |   6 +-
 tst/unit/bundle/variants_test.py           | 175 +++++++++++++++++
 tst/unit/env/envs/test_computer_env.py     |  49 ++++-
 13 files changed, 550 insertions(+), 46 deletions(-)
 create mode 100644 src/agent_env/bundle/variants.py
 create mode 100644 tst/unit/bundle/variants_test.py

diff --git a/src/agent_env/bundle/__init__.py b/src/agent_env/bundle/__init__.py
index 57290f61d..5c736a577 100644
--- a/src/agent_env/bundle/__init__.py
+++ b/src/agent_env/bundle/__init__.py
@@ -3,6 +3,7 @@
 from .parse import Bundle, BundleEntry, BundleError, BundleKind, is_ignored, parse_bundle
 from .run import (BundleRun, DryRun, EvalRun, Outcome, PreparedBundle, RunInterrupted, TaskRun, dry_run_bundle,
                   prepare_bundle, run_bundle)
+from .variants import Variant
 
 __all__ = [
     "Bundle",
@@ -16,6 +17,7 @@
     "PreparedBundle",
     "RunInterrupted",
     "TaskRun",
+    "Variant",
     "dry_run_bundle",
     "is_ignored",
     "parse_bundle",
diff --git a/src/agent_env/bundle/run.py b/src/agent_env/bundle/run.py
index 3d5d94f25..a9e485fb3 100644
--- a/src/agent_env/bundle/run.py
+++ b/src/agent_env/bundle/run.py
@@ -18,6 +18,7 @@
 import shlex
 import time
 import uuid
+from collections import Counter
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, replace
 from enum import Enum
@@ -45,6 +46,7 @@
 from .requires import Declaring, declare, declaring_for
 from .resolve import (BuiltImage, BundleImage, Reference, ReferencedImage, ResolvedEntry, resolve_bundle,
                       without_played_agents)
+from .variants import Variant, with_variant
 
 logger = logging.getLogger(__name__)
 
@@ -220,6 +222,7 @@ def run_bundle(
     keep: bool = False,
     emulate: bool = True,
     source: HubSource | None = None,
+    variant: Variant | None = None,
 ) -> BundleRun:
     """Write what the tasks and evals selected in ``root`` need, as ``plan_bundle`` selects them, then run
     each of their tasks once. ``model``, ``user_model`` and ``judge_model`` replace the models the solver, the
@@ -231,7 +234,8 @@ def run_bundle(
     at each write and step. ``id_root`` roots the ids of a bundle an installed package provides
     (``InstalledBundle.id_root``) or one downloaded from the Hub (``HubBundle.id_root``); a folder's ids otherwise come
     from its path. ``source`` says where a Hub bundle came from (``HubBundle.source``), which each run's context
-    records under ``metadata["bundle_source"]``.
+    records under ``metadata["bundle_source"]``. ``variant`` sets env keys for this run (``with_variant``), writing
+    what it changes under ids of their own and leaving the bundle as written.
 
     Each run's sandboxes are torn down as it ends, so the contexts returned record sandboxes that are gone.
     ``keep`` leaves them up instead, for the caller to use and then remove with ``BundleRun.teardown()``.
@@ -253,7 +257,8 @@ def run_bundle(
     say = _progress(on_progress)
     with namespace_routing():
         prepared = _prepare(root, tasks, evals, sandbox, id_root, agent, False, say,
-                            declaring_for(Path(root), installed=id_root is not None, dry_run=False), composing)
+                            declaring_for(Path(root), installed=id_root is not None, dry_run=False), composing,
+                            variant=variant)
         plan, entries = prepared.plan, [entry for entry, _ in prepared.tasks]
         with Interrupts() as interrupts:
             overrides = _overrides(sandbox, user_model, judge_model)
@@ -339,6 +344,7 @@ def dry_run_bundle(
     on_progress: Callable[[str], None] | None = None,
     id_root: str | None = None,
     emulate: bool = True,
+    variant: Variant | None = None,
 ) -> DryRun:
     """Check what ``run_bundle`` with these arguments checks before its first task runs, and say what it would
     write and run, writing and running nothing: no entity, ledger row, lock or instance. Each write's version is
@@ -352,8 +358,8 @@ def dry_run_bundle(
     composing = _composing(sandbox, emulate)
     say = _progress(on_progress)
     with namespace_routing():
-        plan, preflight = _planned(root, tasks, evals, id_root, sandbox, agent)
-        _say_plan(plan, say, declaring_for(Path(root), installed=id_root is not None, dry_run=True))
+        plan, preflight = _planned(root, tasks, evals, id_root, sandbox, agent, variant=variant)
+        _say_plan(plan, say, declaring_for(Path(root), installed=id_root is not None, dry_run=True), variant)
         materialization = materialize(plan, dry_run=True, on_write=lambda done: say(_written(plan, done)),
                                       composing=composing, sandbox=sandbox,
                                       on_progress=lambda write, line: say(f"{_label(plan, write)}: {line}"))
@@ -385,10 +391,11 @@ def _bundle_run(plan: Plan, materialization: Materialization, runs: tuple[TaskRu
 
 def _prepare(root: Path | str, tasks: Sequence[str], evals: Sequence[str], sandbox: str | None, id_root: str | None,
              agent: str | None, played: bool, say: Callable[[str], None], declaring: Declaring,
-             composing: Composing = Composing(), *, solver_endpoint: bool = False) -> PreparedBundle:
+             composing: Composing = Composing(), *, solver_endpoint: bool = False,
+             variant: Variant | None = None) -> PreparedBundle:
     plan, preflight = _planned(root, tasks, evals, id_root, sandbox, agent, played=played,
-                               solver_endpoint=solver_endpoint)
-    _say_plan(plan, say, declaring)
+                               solver_endpoint=solver_endpoint, variant=variant)
+    _say_plan(plan, say, declaring, variant)
     materialization = _written_with_infra(plan, preflight, say, composing, sandbox)
     to_run = tuple((entry, Task.get(entry.id, materialization.version_of("task", entry.id))) for entry in _to_run(plan))
     return PreparedBundle(plan, materialization, to_run)
@@ -396,11 +403,14 @@ def _prepare(root: Path | str, tasks: Sequence[str], evals: Sequence[str], sandb
 
 def _planned(root: Path | str, tasks: Sequence[str], evals: Sequence[str], id_root: str | None,
              sandbox: str | None, agent: str | None = None, *, played: bool = False,
-             solver_endpoint: bool = False) -> tuple[Plan, Preflight]:
-    resolved = resolve_bundle(parse_bundle(Path(root), id_root=id_root))
+             solver_endpoint: bool = False, variant: Variant | None = None) -> tuple[Plan, Preflight]:
+    bundle = parse_bundle(Path(root), id_root=id_root)
+    resolved = resolve_bundle(with_variant(bundle, variant) if variant else bundle)
     plan = plan_bundle(without_played_agents(resolved) if played else resolved, tasks=tasks, evals=evals,
                        installed=installed_bundles, agent=agent)
     refuse_store_tasks(plan)
+    if variant is not None and not _changed(plan, variant):
+        raise BundleError([f"{variant.typed}: none of the tasks this run selects deploys an env it changes"])
     to_run = set(_to_run(plan))
     return plan, preflight_run(plan, [write.source for write in plan.writes
                                       if write.kind is BundleKind.TASK and write.source.entry in to_run], sandbox,
@@ -451,9 +461,10 @@ def refuse_store_tasks(plan: Plan) -> None:
         raise BundleError(problems)
 
 
-def _say_plan(plan: Plan, say: Callable[[str], None], declaring: Declaring) -> None:
-    """Say what each agent, env and artifact alias names, what the solver deploys in place of the tasks' agents, and
-    what plugin packages the bundle uses that its bundle.toml doesn't require, as ``declaring`` says (``declare``)."""
+def _say_plan(plan: Plan, say: Callable[[str], None], declaring: Declaring, variant: Variant | None = None) -> None:
+    """Say what each agent, env and artifact alias names, what the solver deploys in place of the tasks' agents, the
+    ids ``variant``'s entries are written under, and what plugin packages the bundle uses that its bundle.toml doesn't
+    require, as ``declaring`` says (``declare``)."""
     for use in (use for uses in plan.alias_uses.values() for use in uses.values()):
         say(_aliased(use))
     if plan.agent is not None:
@@ -461,10 +472,21 @@ def _say_plan(plan: Plan, say: Callable[[str], None], declaring: Declaring) -> N
         solved = sum(entry.id in plan.agent.steps for entry in runs)
         say(f"--agent {plan.agent.name}: the solver deploys {plan.agent.agent_id}, in {solved} of {len(runs)} "
             f"task{'s' if len(runs) != 1 else ''}")
+    if variant is not None:
+        say(f"{variant.typed}: {_changed(plan, variant)} written under ids ending in ({variant.label})")
     for line in declare(plan.bundle, declaring):
         say(line)
 
 
+def _changed(plan: Plan, variant: Variant) -> str:
+    """How many envs, tasks and evals ``variant`` changes the run writes: ``1 env and 2 tasks``, or ``""``."""
+    counts = Counter(write.kind for write in plan.writes
+                     if isinstance(write.source, ResolvedEntry) and write.id.endswith(f"({variant.label})"))
+    named = [f"{counts[kind]} {noun}{'s' if counts[kind] != 1 else ''}" for kind, noun in (
+        (BundleKind.ENV, "env"), (BundleKind.TASK, "task"), (BundleKind.EVAL, "eval")) if counts[kind]]
+    return " and ".join([", ".join(named[:-1]), named[-1]] if len(named) > 1 else named)
+
+
 def _hint(id_root: str | None) -> Declaring:
     """How a service writing a bundle declares its plugins: nothing for an installed bundle, else a hint."""
     return Declaring.QUIET if id_root is not None else Declaring.HINT
diff --git a/src/agent_env/bundle/variants.py b/src/agent_env/bundle/variants.py
new file mode 100644
index 000000000..4320625d0
--- /dev/null
+++ b/src/agent_env/bundle/variants.py
@@ -0,0 +1,208 @@
+"""Run-only variants for ``agent-env run --set KEY=VALUE``: the bundle as parsed, with env keys set for one run. Each env
+changed, each env and task that names one, and each eval that names such a task is written under a derived id, so a
+variant is written and composed beside the bundle's own. Entries keep their names, so every reference to one by name
+reaches its variant; the bundle's files stay as written."""
+from __future__ import annotations
+
+import copy
+import hashlib
+import tomllib
+from dataclasses import dataclass, replace
+from typing import Any
+
+from agent_env.entity.refs import EntityKind, ref_sites
+from agent_env.env.registry import get_env_registry
+from agent_env.task_step.registry import get_task_step_registry
+
+from .parse import Bundle, BundleEntry, BundleError, BundleKind, segment_problem
+
+_TARGET = f"{BundleKind.ENV.value}/"
+
+
+@dataclass(frozen=True)
+class Variant:
+    """The ``--set`` settings of a run, as typed: ``KEY=VALUE`` for every env the bundle's tasks deploy whose type takes
+    KEY, or ``envs/NAME.KEY=VALUE`` for one env; KEY may be dotted into a table, VALUE is TOML or a bare word."""
+
+    settings: tuple[str, ...]
+
+    @property
+    def label(self) -> str:
+        """The settings as ids end in them: ``driver cua-driver, display 3f2a9c1e``, a value an id can't hold hashed."""
+        return ", ".join(f"{key.removeprefix(_TARGET)} {_shown(raw)}"
+                         for key, raw in (setting.partition("=")[::2] for setting in self.settings))
+
+    @property
+    def typed(self) -> str:
+        """The settings as the command line gives them."""
+        return " ".join(f"--set {setting}" for setting in self.settings)
+
+
+@dataclass(frozen=True)
+class _Setting:
+    text: str
+    env: str | None  # the env it names, by name; None for every env deployed that takes path[0]
+    path: tuple[str, ...]
+    value: Any
+
+
+def with_variant(bundle: Bundle, variant: Variant) -> Bundle:
+    """``bundle`` with ``variant``'s settings in its envs' tomls, and each entry that changes under an id ending in
+    ``(<label>)``. Raises BundleError for a setting that isn't ``KEY=VALUE``, names no env of the bundle, or that no env
+    the bundle's tasks deploy takes."""
+    envs = [entry for entry in bundle.entries if entry.kind is BundleKind.ENV]
+    settings = _parsed(variant.settings, {entry.name for entry in envs})
+    deployed = _deployed(bundle)
+    configs, problems = {}, []
+    for setting in settings:
+        hit = [entry for entry in envs if setting.env == entry.name or setting.env is None
+               and deployed & {entry.name, entry.id} and setting.path[0] in _keys(entry)]
+        if not hit:
+            problems.append(_untaken(setting, [entry for entry in envs if deployed & {entry.name, entry.id}]))
+        for entry in hit:
+            configs[entry.id] = _set(configs.get(entry.id, entry.config), setting.path, setting.value)
+    if problems:
+        raise BundleError(problems)
+    renamed = _renamed_ids(bundle, set(configs), variant.label)
+    entries = []
+    for entry in bundle.entries:
+        if entry.id not in renamed:
+            entries.append(entry)
+        elif entry.kind is BundleKind.ENV:
+            entries.append(_renamed(entry, renamed, _repointed_toml(entry, configs.get(entry.id, entry.config), renamed)))
+        elif entry.kind is BundleKind.TASK:
+            entries.append(_renamed(entry, renamed, _repointed_steps(entry.config, renamed)))
+        else:
+            entries.append(_renamed(entry, renamed, _eval(entry.config, renamed)))
+    return replace(bundle, entries=tuple(entries))
+
+
+def _parsed(texts: tuple[str, ...], names: set[str]) -> list[_Setting]:
+    settings, problems = [], []
+    for text in texts:
+        key, equals, raw = text.partition("=")
+        env = None
+        if key.startswith(_TARGET):
+            env = max((name for name in names if key.startswith(f"{_TARGET}{name}.")), key=len, default=None)
+            if env is None:
+                problems.append(f"--set {text}: {key.partition('.')[0]} names no env of this bundle")
+                continue
+            key = key.removeprefix(f"{_TARGET}{env}.")
+        path = tuple(key.split("."))
+        if not equals or not all(path):
+            problems.append(f"--set {text}: expected KEY=VALUE, such as driver=cua-driver")
+            continue
+        settings.append(_Setting(text, env, path, _value(raw)))
+    if problems:
+        raise BundleError(problems)
+    return settings
+
+
+def _value(raw: str) -> Any:
+    """``raw`` as a TOML value, or as the string it is when it isn't one, so ``cua-driver`` needs no quotes."""
+    try:
+        return tomllib.loads(f"value = {raw}")["value"]
+    except tomllib.TOMLDecodeError:
+        return raw
+
+
+def _shown(raw: str) -> str:
+    return raw if raw and segment_problem(raw) is None else hashlib.sha256(raw.encode()).hexdigest()[:8]
+
+
+def _deployed(bundle: Bundle) -> set[str]:
+    """The envs the bundle's tasks deploy, as their steps name them."""
+    return {step["env_id"] for entry in bundle.entries if entry.kind is BundleKind.TASK for step in entry.config
+            if step.get("type") == "deploy_env" and isinstance(step.get("env_id"), str)}
+
+
+def _keys(entry: BundleEntry) -> dict[str, type]:
+    cls = get_env_registry().get(entry.type)
+    return getattr(cls, "toml_keys", None) or {}
+
+
+def _untaken(setting: _Setting, deployed: list[BundleEntry]) -> str:
+    takes = {entry.type: sorted(_keys(entry)) for entry in deployed if _keys(entry)}
+    named = "; ".join(f"a {kind} env takes {', '.join(keys)}" for kind, keys in sorted(takes.items()))
+    return f"--set {setting.text}: no env this bundle's tasks deploy takes {setting.path[0]}" + (f"; {named}" if named else "")
+
+
+def _set(config: dict, path: tuple[str, ...], value: Any) -> dict:
+    config = copy.deepcopy(config)
+    table = config
+    for key in path[:-1]:
+        if not isinstance(table.get(key), dict):
+            table[key] = {}
+        table = table[key]
+    table[path[-1]] = value
+    return config
+
+
+def _renamed_ids(bundle: Bundle, changed: set[str], label: str) -> dict[str, str]:
+    """Each id that changes, to its variant's: the envs set, each env and task naming one that changes, by name or id,
+    and each eval naming such a task."""
+    by_name = {(entry.kind, entry.name): entry.id for entry in bundle.entries}
+    changing = set(changed)
+    while True:
+        more = {entry.id for entry in bundle.entries if entry.id not in changing and entry.kind in (
+            BundleKind.ENV, BundleKind.TASK) and _names_env(entry, changing, by_name)}
+        if not more:
+            break
+        changing |= more
+    tasks = {entry.id for entry in bundle.entries if entry.kind is BundleKind.TASK and entry.id in changing}
+    changing |= {entry.id for entry in bundle.entries if entry.kind is BundleKind.EVAL and any(
+        by_name.get((BundleKind.TASK, task), task) in tasks for task in entry.config.get("tasks") or []
+        if isinstance(task, str))}
+    return {entry_id: f"{entry_id}({label})" for entry_id in changing}
+
+
+def _names_env(entry: BundleEntry, changing: set[str], by_name: dict) -> bool:
+    return any(by_name.get((BundleKind.ENV, site.value), site.value) in changing for site in _env_sites(entry))
+
+
+def _env_sites(entry: BundleEntry):
+    if entry.kind is BundleKind.TASK:
+        registry = get_task_step_registry()
+        for step in entry.config:
+            cls = registry.get(step.get("type")) if isinstance(step.get("type"), str) else None
+            yield from (site for site in ref_sites(cls.entity_refs or () if cls is not None else (), step)
+                        if site.ref.kind is EntityKind.ENV and isinstance(site.value, str))
+    else:
+        cls = get_env_registry().get(entry.type)
+        yield from (site for site in ref_sites(getattr(cls, "toml_refs", ()), entry.config, inline_pins=True)
+                    if site.ref.kind is EntityKind.ENV and isinstance(site.value, str))
+
+
+def _renamed(entry: BundleEntry, renamed: dict[str, str], config: Any) -> BundleEntry:
+    """``entry`` under its variant's id with ``config``, whose declared id, when it has one, is that id too."""
+    if isinstance(config, dict) and "id" in config:
+        config = {**config, "id": renamed[entry.id]}
+    return replace(entry, id=renamed[entry.id], config=config)
+
+
+def _repointed_toml(entry: BundleEntry, config: dict, renamed: dict[str, str]) -> dict:
+    """An env's toml with each env it names by an id that changes named by its variant's id."""
+    config = copy.deepcopy(config)
+    cls = get_env_registry().get(entry.type)
+    for site in ref_sites(getattr(cls, "toml_refs", ()), config, inline_pins=True):
+        if site.ref.kind is EntityKind.ENV and site.value in renamed:
+            site.rewrite(renamed[site.value], site.version)
+    return config
+
+
+def _repointed_steps(steps: list[dict], renamed: dict[str, str]) -> list[dict]:
+    """A task's steps with each env a step names by an id that changes named by its variant's id."""
+    steps = copy.deepcopy(steps)
+    registry = get_task_step_registry()
+    for step in steps:
+        cls = registry.get(step.get("type")) if isinstance(step.get("type"), str) else None
+        for site in ref_sites(cls.entity_refs or () if cls is not None else (), step):
+            if site.ref.kind is EntityKind.ENV and site.value in renamed:
+                site.rewrite(renamed[site.value], site.version)
+    return steps
+
+
+def _eval(config: dict, renamed: dict[str, str]) -> dict:
+    """An eval's toml with each task it names by an id that changes named by its variant's id."""
+    return {**config, "tasks": [renamed.get(task, task) if isinstance(task, str) else task
+                                for task in config.get("tasks") or []]}
diff --git a/src/agent_env/cli/run.py b/src/agent_env/cli/run.py
index 85f22f82f..d9282b969 100644
--- a/src/agent_env/cli/run.py
+++ b/src/agent_env/cli/run.py
@@ -11,7 +11,7 @@
 
 import click
 
-from agent_env.bundle import (BundleError, BundleKind, BundleRun, DryRun, Outcome, RunInterrupted, TaskRun,
+from agent_env.bundle import (BundleError, BundleKind, BundleRun, DryRun, Outcome, RunInterrupted, TaskRun, Variant,
                               dry_run_bundle, run_bundle)
 from agent_env.bundle.hub import SOURCE_KEY, HubSource
 from agent_env.bundle.installed import (InstalledBundle, checked, find_bundle, installed_bundles, locate_bundle,
@@ -43,6 +43,10 @@
 @click.option("--agent", default=None,
               help="The agent the solver runs as, whatever the tasks name: an alias such as pi, an agent of this "
                    "bundle or an installed one, or the store's.")
+@click.option("--set", "settings", multiple=True, metavar="KEY=VALUE",
+              help="Set an env key for this run, whatever the bundle's env.toml files say: in every env the tasks "
+                   "deploy whose type takes KEY, or in one as envs/NAME.KEY=VALUE. VALUE is TOML or a bare word, and "
+                   "KEY may be dotted into a table. Repeatable. Such as driver=cua-driver or tools=standard.")
 @click.option("--sandbox", default=None,
               help="The sandbox provider envs, agents, sandboxes and the judge deploy on, which picks the forms "
                    "computer envs compose on this machine; comma-separated for a fallback chain.")
@@ -56,8 +60,8 @@
                    "natively; a later run or env build builds it.")
 @click.pass_context
 def run(ctx: click.Context, bundle: str | None, tasks: tuple[str, ...], evals: tuple[str, ...], model: str | None,
-        user_model: str | None, judge_model: str | None, agent: str | None, sandbox: str | None, keep: bool,
-        dry_run: bool, no_emulate: bool):
+        user_model: str | None, judge_model: str | None, agent: str | None, settings: tuple[str, ...],
+        sandbox: str | None, keep: bool, dry_run: bool, no_emulate: bool):
     """Run a bundle's tasks and evals, or list the installed bundles.
 
     BUNDLE is a folder, the name of a bundle an installed package provides (PACKAGE/NAME when several
@@ -80,6 +84,14 @@ def run(ctx: click.Context, bundle: str | None, tasks: tuple[str, ...], evals: t
     agent the solver runs as: each step that deploys or installs the agent a task prompts deploys it instead,
     while its user simulator and judges keep theirs.
 
+    --set sets env keys for this run, as the env.toml files would: --set driver=cua-driver runs every computer env
+    the tasks deploy with that driver, and --set envs/desktop.computer=ubuntu-24.04-headless composes one on that
+    base. The envs it changes, the envs and tasks that name them and the evals that name those tasks are written
+    under ids of their own, ending in the settings, such as desktop(driver cua-driver), and compose and reuse their
+    images as any env does, leaving the bundle as written. A key no env the tasks deploy takes, or a value the env's
+    type refuses, is refused before anything is written; a driver and computer that can't compose, as the run writes
+    the env, before any task runs.
+
     --dry-run makes the checks the run makes before its first task, reading the stores as the run does, and
     prints what it would write and run, writing and running nothing. It exits 1 on a problem the run would
     stop at, and 0 otherwise; the models and --keep change nothing it shows, and --agent what it writes and checks
@@ -91,23 +103,27 @@ def run(ctx: click.Context, bundle: str | None, tasks: tuple[str, ...], evals: t
     exits 130 (143 for SIGTERM); a second one stops the teardown and prints what is still up.
     """
     if bundle is None:
-        if tasks or evals or model or user_model or judge_model or agent or sandbox or keep or dry_run or no_emulate:
-            raise click.UsageError("--task, --eval, --model, --user-model, --judge-model, --agent, --sandbox, --keep, "
-                                   "--dry-run and --no-emulate need a BUNDLE to run")
+        if tasks or evals or model or user_model or judge_model or agent or settings or sandbox or keep or dry_run \
+                or no_emulate:
+            raise click.UsageError("--task, --eval, --model, --user-model, --judge-model, --agent, --set, --sandbox, "
+                                   "--keep, --dry-run and --no-emulate need a BUNDLE to run")
         _list_installed()
         return
     verbose = ctx.find_root().params.get("verbose")
+    variant = Variant(settings) if settings else None
     root = id_root = hub = None
     try:
         root, id_root, hub = locate_bundle(bundle, _installed, on_progress=click.echo)
         if dry_run:
             click.echo(_DRY_RUN)
             _report_dry_run(dry_run_bundle(root, tasks=tasks, evals=evals, sandbox=sandbox, agent=agent,
-                                           on_progress=click.echo, id_root=id_root, emulate=not no_emulate))
+                                           on_progress=click.echo, id_root=id_root, emulate=not no_emulate,
+                                           variant=variant))
             return
         result = run_bundle(root, tasks=tasks, evals=evals, model=model, user_model=user_model,
                             judge_model=judge_model, agent=agent, sandbox=sandbox, on_progress=click.echo,
-                            id_root=id_root, keep=keep, emulate=not no_emulate, source=hub.source if hub else None)
+                            id_root=id_root, keep=keep, emulate=not no_emulate, source=hub.source if hub else None,
+                            variant=variant)
     except BundleError as e:
         if root is not None:
             _note_an_installed_namesake(e, bundle, root, id_root)
diff --git a/src/agent_env/computers/README.md b/src/agent_env/computers/README.md
index a8fff484e..fc4fb5a78 100644
--- a/src/agent_env/computers/README.md
+++ b/src/agent_env/computers/README.md
@@ -1,4 +1,6 @@
 Base computers that come with agent-env, each a `computer` artifact a computer env composes a driver and apps onto.
+`agent-env run <bundle> --set computer=ubuntu-24.04-headless` composes a bundle's computer envs on another of them
+for one run, the bundle left as written.
 
 `artifacts/ubuntu-24.04/` is Ubuntu 24.04 (`amd64` and `arm64`) with XFCE on Xvfb, D-Bus and AT-SPI. tini starts
 supervisord, which runs every program as the session user, `user` (uid 1000); nothing in it runs as root. Its home
diff --git a/src/agent_env/drivers/README.md b/src/agent_env/drivers/README.md
index b1a464fb1..26c7272bb 100644
--- a/src/agent_env/drivers/README.md
+++ b/src/agent_env/drivers/README.md
@@ -1,4 +1,9 @@
 Computer drivers that come with agent-env, each a `computer_driver` env a computer env serves its tools through.
+A computer env's `tools` is what its agents get: `standard`, AgentEnv's `computer_*` tools alone;
+`driver`, the driver's own alone; or `both`, the default. `agent-env run <bundle> --set driver=cua-driver` runs a
+bundle's computer envs with another driver for one run, and `--set tools=driver` gives their agents the driver's own
+tools; the bundle stays as written, and what changes is written under ids ending in the settings, such as
+`desktop(driver cua-driver)`.
 
 `envs/reference/` is the reference driver, for an X11 desktop on Linux (`amd64` and `arm64`): `mss` captures the
 screen and XTEST, through `python-xlib`, sends the input, foreground only. It serves the seven `computer_*` tools, the
diff --git a/src/agent_env/drivers/aliases.toml b/src/agent_env/drivers/aliases.toml
index d5e9aa401..df418f49f 100644
--- a/src/agent_env/drivers/aliases.toml
+++ b/src/agent_env/drivers/aliases.toml
@@ -1,4 +1,4 @@
-# Ids a task, or --driver, can name these drivers by; a store's env of the id wins over an alias.
+# Ids a task, or --set driver=, can name these drivers by; a store's env of the id wins over an alias.
 [envs]
 reference = ["reference"]
 cua-driver = ["cua-driver"]
diff --git a/src/agent_env/env/envs/_deployment.py b/src/agent_env/env/envs/_deployment.py
index 7659455b0..3c9138320 100644
--- a/src/agent_env/env/envs/_deployment.py
+++ b/src/agent_env/env/envs/_deployment.py
@@ -7,6 +7,7 @@
 import inspect
 import logging
 import uuid
+from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Optional
 
 from agentenv_protocol import DATA_OBJECTS_EXTENSION_URI, METHOD_ADD, METHOD_RESET, RPC_PATH, FilePart, client as protocol_v1
@@ -31,8 +32,10 @@
 
 
 async def deploy_through_provider(env: Env, *, environment_name: str | None, ttl_seconds: int, sandbox_type: str | None,
+                                  then: Callable[[DeployedEnv], Awaitable[None]] | None = None,
                                   **options) -> DeployedEnv:
-    """Deploy env through the provider its env_provider_type names and register the record, the way each built-in env deploys.
+    """Deploy env through the provider its env_provider_type names and register the record, the way each built-in env deploys,
+    then await ``then`` on it, whose failure fails the deploy.
 
     The env's provider deploys it the first time; a deploy of an env that already has a deployment gets a provider of its own,
     so that a failure closes only what it started and leaves the earlier deployment as it was. A deploy onto the env state
@@ -71,6 +74,8 @@ async def deploy_through_provider(env: Env, *, environment_name: str | None, ttl
         deployed = register_env_instance(deployed, ttl_seconds)
         env._instance_id = deployed.instance_id
         env._deployed, env._replaced = deployed, replaced
+        if then is not None:
+            await then(deployed)
         return deployed
     except BaseException:
         try:
diff --git a/src/agent_env/env/envs/computer/app_env.py b/src/agent_env/env/envs/computer/app_env.py
index bb339b346..499fee7d1 100644
--- a/src/agent_env/env/envs/computer/app_env.py
+++ b/src/agent_env/env/envs/computer/app_env.py
@@ -34,6 +34,8 @@ class ComputerAppEnv(ComputerEnv):
     type: ClassVar[str] = APP_TYPE
     description = ("A computer app: software and its settings on a computer, read from its ComputerAppEnvironment "
                    "class at put; deployed alone, a computer of its own")
+    toml_keys: ClassVar[dict[str, type]] = {"environment_name": str, "module": str, "computer": object, "driver": object,
+                                            "build_settings": dict, "settings": dict}
 
     def __init__(self, id: str, version: Optional[int], environment_name: str, module: str, files: FileArtifactUniverse,
                  declaration: AppDeclaration, computer: Optional[ComputerArtifact] = None,
@@ -166,8 +168,7 @@ def accept_toml(cls, data: dict, ctx: AuthoringContext) -> dict:
         its folder; ``environment_name``, the folder's when it sets none; the ``computer`` and ``driver`` it deploys
         alone on; ``build_settings``, the values of its build settings; and ``settings``, defaults for some of its
         settings that a deploy's ``env_params`` override field by field. Raises BundleError listing every problem."""
-        fields, refused = ctx.accepted(data, environment_name=str, module=str, computer=object, driver=object,
-                                       build_settings=dict, settings=dict)
+        fields, refused = ctx.accepted(data, **cls.toml_keys)
         files, module, problems = ctx.files(), fields.get("module"), []
         if module is None and "module" not in data:
             problems.append('module is required: the app\'s file and class, such as "app.py:MailApp"')
diff --git a/src/agent_env/env/envs/computer/env.py b/src/agent_env/env/envs/computer/env.py
index 8006d7d91..ecbda1aaa 100644
--- a/src/agent_env/env/envs/computer/env.py
+++ b/src/agent_env/env/envs/computer/env.py
@@ -13,6 +13,10 @@
 
 from agentenv_protocol import METHOD_ADD, RPC_PATH
 from agentenv_protocol import client as protocol_v1
+from agentenv_protocol.computer.tools import Tools
+from agentenv_protocol.tool_access import (DISABLE, DISABLE_TOOL_EXTENSION_URI, ENABLE, ENABLE_TOOL_EXTENSION_URI,
+                                           WILDCARD)
+from agentenv_protocol.tool_context import DEFAULT_ROLE
 
 from agent_env.artifact.artifacts.computer import ComputerArtifact, SettingValue
 from agent_env.attribution import Attribution
@@ -56,6 +60,13 @@
 #: The statuses of a build a deploy boots, by form: a disk may also boot unprobed, as KVM is where a disk is probed, and
 #: so may a VM bundle, which a Mac probes.
 _DEPLOYABLE = {"container": ("ready",), "disk": ("ready", "unverified"), "vm_bundle": ("ready", "unverified")}
+#: Every ``computer_*`` tool a driver can serve.
+COMPUTER_TOOLS = tuple(sorted(name for name in vars(Tools) if name.startswith("computer_")))
+#: What a computer env's ``tools`` gives its agents, as the tool-access changes a deploy makes for them: ``standard``,
+#: AgentEnv's ``computer_*`` tools alone; ``driver``, the driver's own alone; ``both``, every tool it serves.
+TOOLS = {"standard": ((DISABLE, [WILDCARD]), (ENABLE, list(COMPUTER_TOOLS))), "driver": ((DISABLE, list(COMPUTER_TOOLS)),),
+         "both": ()}
+_TOOL_ACCESS_URIS = {DISABLE: DISABLE_TOOL_EXTENSION_URI, ENABLE: ENABLE_TOOL_EXTENSION_URI}
 
 
 class ComputerEnv(Env):
@@ -66,15 +77,18 @@ class ComputerEnv(Env):
                                                   EntityRef.env("driver", env_type=ComputerDriverEnv.type),
                                                   EntityRef.env("apps[]", env_type=APP_TYPE,
                                                                 beside=("install", "settings")))
+    toml_keys: ClassVar[dict[str, type]] = {"environment_name": str, "computer": object, "driver": object, "apps": list,
+                                            "display": dict, "network": dict, "computer_settings": dict, "tools": str}
 
     def __init__(self, id: str, version: Optional[int], environment_name: str, computer: ComputerArtifact,
                  driver: ComputerDriverEnv, display: Optional[dict] = None, network: Optional[dict] = None,
                  computer_settings: Optional[dict[str, SettingValue]] = None, metadata: Optional[dict[str, Any]] = None,
-                 apps: Optional[list[ComputerAppEnv]] = None, app_settings: Optional[dict[str, dict]] = None):
+                 apps: Optional[list[ComputerAppEnv]] = None, app_settings: Optional[dict[str, dict]] = None,
+                 tools: Optional[str] = None):
         super().__init__(id, version, metadata=metadata)
         self.environment_name = environment_name
         self.computer, self.driver, self.apps = computer, driver, apps or []
-        self.display, self.network = display, network
+        self.display, self.network, self.tools = display, network, tools
         self.computer_settings = computer_settings or {}
         self.app_settings = app_settings or {}
         self._sandbox = None
@@ -89,6 +103,7 @@ def to_dict(self) -> dict:
                 "computer": {"id": self.computer.id, "version": self.computer.version},
                 "driver": {"id": self.driver.id, "version": self.driver.version}, "display": self.display,
                 "network": self.network, "computer_settings": self.computer_settings,
+                **({"tools": self.tools} if self.tools else {}),
                 **({"apps": [{"id": app.id, "version": app.version,
                               **({"settings": own} if (own := self.app_settings.get(app.environment_name)) else {})}
                              for app in self.apps]} if self.apps else {})}
@@ -106,21 +121,21 @@ def from_dict(cls, data: dict) -> ComputerEnv:
                    display=data.get("display"), network=data.get("network"),
                    computer_settings=data.get("computer_settings"), metadata=data.get("metadata") or {}, apps=apps,
                    app_settings={app.environment_name: ref["settings"] for app, ref in zip(apps, refs)
-                                 if ref.get("settings")})
+                                 if ref.get("settings")}, tools=data.get("tools"))
 
     @classmethod
     def put(cls, *, id: str, computer: ComputerArtifact, driver: ComputerDriverEnv, environment_name: str,
             apps: Any = (), display: Any = None, network: Any = None, computer_settings: Any = None,
-            app_settings: Optional[dict[str, dict]] = None, compose: bool = True,
+            app_settings: Optional[dict[str, dict]] = None, tools: Optional[str] = None, compose: bool = True,
             composing: Composing = Composing()) -> Self:
         """Write a computer env of ``computer``, ``driver`` and ``apps``, computer app envs built into it in their
-        order, with ``app_settings``, defaults for some of their settings by app name, once gate 1 passes, then compose
-        it as ``composing`` says unless ``compose`` is False. Refused, naming every mismatch, before anything is
-        stored."""
+        order, with ``app_settings``, defaults for some of their settings by app name, and ``tools``, which of them its
+        agents get (``TOOLS``), once gate 1 passes, then compose it as ``composing`` says unless ``compose`` is False.
+        Refused, naming every mismatch, before anything is stored."""
         apps, app_settings = list(apps), app_settings or {}
         values, problems = gate.check(computer, driver, environment_name=environment_name, apps=apps, display=display,
                                       network=network, computer_settings=computer_settings or {})
-        problems += gate.check_screen(driver, apps)
+        problems += gate.check_screen(driver, apps) + _tools_problems(tools)
         by_name = {app.environment_name: app for app in apps}
         for name, defaults in app_settings.items():
             problems += ([f"apps.{name}.settings: {id} has no app {name!r}"] if name not in by_name else
@@ -130,7 +145,7 @@ def put(cls, *, id: str, computer: ComputerArtifact, driver: ComputerDriverEnv,
             raise ValueError(f"computer env {id!r}: " + "; ".join(problems))
         env = get_env_store().put_document(cls(
             id=id, version=None, environment_name=environment_name, computer=computer, driver=driver, apps=apps,
-            display=display, network=network, computer_settings=values, app_settings=app_settings))
+            display=display, network=network, computer_settings=values, app_settings=app_settings, tools=tools))
         if compose:
             composer.compose(env, composing=composing)
         return env
@@ -152,12 +167,12 @@ def from_toml(cls, data: dict, ctx: AuthoringContext) -> ComputerEnv:
     @classmethod
     def accept_toml(cls, data: dict, ctx: AuthoringContext) -> dict:
         """The keys of ``data``, an env.toml, a computer env takes: the ``computer`` and ``driver`` it's composed of,
-        both required, its ``apps``, ``display``, ``network`` and ``computer_settings``, and ``environment_name``, the
-        folder's when it sets none. Raises BundleError listing every problem."""
-        fields, refused = ctx.accepted(data, environment_name=str, computer=object, driver=object, apps=list,
-                                       display=dict, network=dict, computer_settings=dict)
+        both required, its ``apps``, ``display``, ``network``, ``computer_settings`` and ``tools``, and
+        ``environment_name``, the folder's when it sets none. Raises BundleError listing every problem."""
+        fields, refused = ctx.accepted(data, **cls.toml_keys)
         missing = [ctx.config_problem(f"{key} is required: the {what}, such as {example}") for key, what, example in (
             ("computer", "base computer", '"ubuntu-24.04"'), ("driver", "driver", '"reference"')) if key not in data]
+        refused += [ctx.config_problem(problem) for problem in _tools_problems(fields.get("tools"))]
         if refused or missing:
             ctx.refuse([*refused, *missing])
         return {"environment_name": ctx.name, **fields}
@@ -260,7 +275,7 @@ async def deploy(self, ttl_seconds: int = 10800, disk_size_gb: float = 10,
                      env_params: Optional[dict] = None) -> DeployedEnv:
         return await deploy_through_provider(
             self, environment_name=self.environment_name, ttl_seconds=ttl_seconds, sandbox_type=sandbox_type,
-            disk_size_gb=disk_size_gb, gateway_mode=gateway_mode, cpu=cpu, memory_mb=memory_mb,
+            then=self._give_tools, disk_size_gb=disk_size_gb, gateway_mode=gateway_mode, cpu=cpu, memory_mb=memory_mb,
             env_state_type=env_state_type, env_state_instance_id=env_state_instance_id, attribution=attribution,
             env_params=env_params)
 
@@ -365,8 +380,15 @@ async def load_environment_universe_artifact(self, environment_universe_artifact
     async def reset(self, deployed: DeployedEnv) -> None:
         """Return the computer to boot state: its recordings ended, its container replaced with a fresh one of the same
         image, on the same sandbox and port, so its address stays. An agent's MCP session ends with the old driver; one
-        held across the reset is answered 404, and MCP clients then start a new one."""
+        held across the reset is answered 404, and MCP clients then start a new one. Its agents get its ``tools``
+        again, as at deploy."""
         await as_builtin(self._env_provider).reboot(self, deployed)
+        await self._give_tools(deployed)
+
+    async def _give_tools(self, deployed: DeployedEnv) -> None:
+        """Make the tool-access changes ``tools`` makes for the agents' role, which a task's own then follow."""
+        for action, tools in TOOLS[self.tools or "both"]:
+            await deployed.invoke(_TOOL_ACCESS_URIS[action], action, {"role": DEFAULT_ROLE, "tools": tools})
 
     async def close(self) -> None:
         """End the computer's recordings, so what they recorded reaches the store, then tear it down."""
@@ -477,3 +499,8 @@ def _waiting(awaited: dict[tuple[str, str], str | None], seconds: float) -> str:
     building = f"building since {datetime.fromisoformat(since).strftime('%H:%M')} UTC" if since else "building"
     so_far = f", {composer.took(seconds)} so far" if seconds >= 1 else ""
     return f"waiting for another deploy composing {_pairs(list(awaited)) or 'it'} ({building}{so_far})"
+
+
+def _tools_problems(tools: Any) -> list[str]:
+    return [] if tools is None or tools in TOOLS else [
+        f"tools is {', '.join(map(repr, list(TOOLS)[:-1]))} or {list(TOOLS)[-1]!r}, not {tools!r}"]
diff --git a/tst/unit/bundle/installed_test.py b/tst/unit/bundle/installed_test.py
index a006092b5..9f2197251 100644
--- a/tst/unit/bundle/installed_test.py
+++ b/tst/unit/bundle/installed_test.py
@@ -281,11 +281,11 @@ def test_the_cli_says_so_when_no_bundles_are_installed_and_needs_a_bundle_for_it
 
     assert CliRunner().invoke(cli, ["run"]).output == "No bundles are installed. agent-env run PATH runs a folder.\n"
     for option in (["--task", "t"], ["--keep"], ["--dry-run"], ["--user-model", "m"], ["--judge-model", "m"],
-                   ["--agent", "pi"], ["--no-emulate"]):
+                   ["--agent", "pi"], ["--set", "driver=reference"], ["--no-emulate"]):
         usage = CliRunner().invoke(cli, ["run", *option])
         assert usage.exit_code == 2
-        assert ("--task, --eval, --model, --user-model, --judge-model, --agent, --sandbox, --keep, --dry-run and "
-                "--no-emulate need a BUNDLE to run") in " ".join(usage.output.split())
+        assert ("--task, --eval, --model, --user-model, --judge-model, --agent, --set, --sandbox, --keep, --dry-run "
+                "and --no-emulate need a BUNDLE to run") in " ".join(usage.output.split())
 
 
 def test_the_cli_runs_an_installed_bundle_by_name_with_ids_rooted_at_its_package(site, monkeypatch, quiet_logs,
diff --git a/tst/unit/bundle/variants_test.py b/tst/unit/bundle/variants_test.py
new file mode 100644
index 000000000..5e0bc496b
--- /dev/null
+++ b/tst/unit/bundle/variants_test.py
@@ -0,0 +1,175 @@
+"""``--set KEY=VALUE``: a run's envs with keys set for that run alone, each env that changes, each env and task naming
+one and each eval naming such a task under an id ending in the settings, with the bundle as written."""
+
+import json
+
+import pytest
+from click.testing import CliRunner
+
+from agent_env.bundle import BundleError, Variant, dry_run_bundle, parse_bundle
+from agent_env.bundle.installed import installed_bundles
+from agent_env.bundle.materialize import materialize
+from agent_env.bundle.plan import plan_bundle
+from agent_env.bundle.resolve import resolve_bundle
+from agent_env.bundle.variants import with_variant
+from agent_env.cli import cli
+from agent_env.env import Env
+from tst.unit.bundle._support import layout, local_builds
+from tst.unit.bundle.agent_override_test import _store_agent
+from tst.unit.bundle.computer_env_folder_test import APPS, DESKTOP, UBUNTU, WITH_APPS, composed  # noqa: F401
+
+ROOT = "@local/~/desk"
+CUA = "@local/agentenv-framework/drivers/cua-driver"
+DEPLOY = {"id": "desk", "type": "deploy_env", "env_id": "desktop"}
+AGENT = {"id": "agent", "type": "deploy_agent", "env_ids": ["desktop"], "a2a_agent_id": "theirs", "depends_on": ["desk"]}
+PROMPT = {"id": "ask", "type": "prompt_agent", "prompt_id": "ask", "prompt": "hi", "depends_on": ["agent"]}
+ALONE = [{"id": "agent", "type": "deploy_agent", "env_ids": [], "a2a_agent_id": "theirs"}, PROMPT]
+
+
+@pytest.fixture(autouse=True)
+def home(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+
+
+def _bundle(root, steps=(DEPLOY, AGENT, PROMPT), files=None):
+    return layout(root, {"envs/desktop/env.toml": DESKTOP, "tasks/t.json": json.dumps(list(steps)),
+                         "tasks/chat.json": json.dumps(ALONE), "evals/e.toml": 'tasks = ["t"]\n',
+                         "evals/chats.toml": 'tasks = ["chat"]\n', **(files or {})})
+
+
+def _varied(root, *settings):
+    return with_variant(parse_bundle(root), Variant(settings))
+
+
+def _entry(bundle, name):
+    return next(entry for entry in bundle.entries if entry.name == name)
+
+
+def _ids(bundle):
+    return {entry.name: entry.id for entry in bundle.entries}
+
+
+def test_a_key_set_renames_the_env_and_what_uses_it_and_leaves_the_rest(tmp_path):
+    root = _bundle(tmp_path / "desk")
+
+    bundle = _varied(root, "driver=cua-driver")
+
+    assert _ids(bundle) == {"desktop": f"{ROOT}/desktop(driver cua-driver)", "t": f"{ROOT}/t(driver cua-driver)",
+                            "chat": f"{ROOT}/chat", "e": f"{ROOT}/e(driver cua-driver)", "chats": f"{ROOT}/chats"}
+    assert _entry(bundle, "desktop").config == {**_entry(parse_bundle(root), "desktop").config, "driver": "cua-driver"}
+    assert _entry(bundle, "t").config == [DEPLOY, AGENT, PROMPT]
+
+
+def test_a_reference_by_id_is_repointed_at_the_variant(tmp_path):
+    steps = [{**DEPLOY, "env_id": f"{ROOT}/desktop"}, {**AGENT, "env_ids": [f"{ROOT}/desktop"]}, PROMPT]
+    root = _bundle(tmp_path / "desk", steps, {"evals/e.toml": f'tasks = ["{ROOT}/t"]\n'})
+
+    bundle = _varied(root, "computer=ubuntu-24.04-headless", "tools=standard")
+
+    label = "computer ubuntu-24.04-headless, tools standard"
+    assert [step.get("env_id") or step.get("env_ids") for step in _entry(bundle, "t").config] == [
+        f"{ROOT}/desktop({label})", [f"{ROOT}/desktop({label})"], None]
+    assert _entry(bundle, "e").config["tasks"] == [f"{ROOT}/t({label})"]
+    assert _entry(bundle, "desktop").config["tools"] == "standard"
+
+
+def test_a_value_is_toml_or_a_bare_word_and_a_key_may_be_dotted_into_a_table(tmp_path):
+    settings = ("display={ width = 1280, height = 720 }", "computer_settings.theme=dark",
+                "envs/desktop.network.mode=allow_all")
+
+    bundle = _varied(_bundle(tmp_path / "desk"), *settings)
+
+    config = _entry(bundle, "desktop").config
+    assert (config["display"], config["computer_settings"], config["network"]) == (
+        {"width": 1280, "height": 720}, {"timezone": "Europe/Paris", "theme": "dark"}, {"mode": "allow_all"})
+    hashed = Variant(settings).label.split(",")[0]
+    assert hashed.startswith("display ") and len(hashed) == len("display ") + 8
+    assert _entry(bundle, "desktop").id == f"{ROOT}/desktop({hashed}, computer_settings.theme dark, desktop.network.mode allow_all)"
+
+
+def test_one_env_is_set_by_its_folder_and_an_env_composing_an_app_set_is_renamed_too(tmp_path):
+    files = {"envs/desktop/env.toml": WITH_APPS, "envs/laptop/env.toml": DESKTOP, **APPS,
+             "tasks/u.json": json.dumps([{**DEPLOY, "env_id": "laptop"}])}
+    setting = "envs/mail.settings.signature=Ada"
+
+    bundle = _varied(_bundle(tmp_path / "desk", files=files), setting)
+
+    ids, label = _ids(bundle), Variant((setting,)).label
+    assert label == "mail.settings.signature Ada"
+    assert (ids["mail"], ids["desktop"], ids["t"]) == (f"{ROOT}/mail({label})", f"{ROOT}/desktop({label})",
+                                                       f"{ROOT}/t({label})")
+    assert (ids["notes"], ids["laptop"], ids["u"]) == (f"{ROOT}/notes", f"{ROOT}/laptop", f"{ROOT}/u")
+    assert _entry(bundle, "mail").config["settings"] == {"signature": "Ada"}
+
+
+@pytest.mark.parametrize("setting, problem", [
+    ("drivr=x", "--set drivr=x: no env this bundle's tasks deploy takes drivr; a computer env takes apps, computer, "
+                "computer_settings, display, driver, environment_name, network, tools"),
+    ("envs/nope.driver=x", "--set envs/nope.driver=x: envs/nope names no env of this bundle"),
+    ("driver", "--set driver: expected KEY=VALUE, such as driver=cua-driver"),
+    ("=x", "--set =x: expected KEY=VALUE, such as driver=cua-driver"),
+])
+def test_a_setting_no_env_can_take_is_refused(tmp_path, setting, problem):
+    with pytest.raises(BundleError) as refused:
+        _varied(_bundle(tmp_path / "desk"), setting)
+
+    assert refused.value.problems == (problem,)
+
+
+@pytest.fixture
+def desk(tmp_path, local_stores, cli_routing):
+    _store_agent("theirs")
+    return _bundle(tmp_path / "desk")
+
+
+def _plan(root, *settings):
+    return plan_bundle(resolve_bundle(_varied(root, *settings)), installed=installed_bundles)
+
+
+def test_the_variant_is_written_and_composed_with_its_driver_beside_the_bundles_own(desk, composed):  # noqa: F811
+    plan = _plan(desk, "driver=cua-driver", "tools=driver")
+
+    materialize(plan, build_here=local_builds(plan))
+
+    env = Env.get(f"{ROOT}/desktop(driver cua-driver, tools driver)")
+    assert (env.computer.id, env.driver.id, env.environment_name, env.tools) == (UBUNTU, CUA, "desktop", "driver")
+    assert composed == [(env.id, UBUNTU, CUA, None)]
+    assert (desk / "envs/desktop/env.toml").read_text() == DESKTOP
+
+
+def test_a_value_the_envs_type_refuses_is_refused_before_anything_is_written(desk, composed):  # noqa: F811
+    with pytest.raises(BundleError) as refused:
+        dry_run_bundle(desk, variant=Variant(("tools=all",)))
+
+    assert any(line.startswith("envs/desktop") and "tools is 'standard', 'driver' or 'both', not 'all'" in line
+               for line in refused.value.problems), refused.value
+
+
+def test_a_driver_that_cant_compose_with_the_computer_is_refused_as_its_written(desk, composed):  # noqa: F811
+    plan = _plan(desk, "driver=macos-harness")
+
+    with pytest.raises(BundleError) as refused:
+        materialize(plan, build_here=local_builds(plan))
+
+    assert any(line.startswith("envs/desktop") and "macos-harness" in line for line in refused.value.problems), (
+        refused.value)
+    assert composed == []
+
+
+def test_a_run_whose_tasks_deploy_nothing_its_settings_change_is_refused(desk, composed):  # noqa: F811
+    with pytest.raises(BundleError) as refused:
+        dry_run_bundle(desk, tasks=["chat"], variant=Variant(("driver=cua-driver",)))
+
+    assert refused.value.problems == ("--set driver=cua-driver: none of the tasks this run selects deploys an env it "
+                                      "changes",)
+
+
+def test_the_cli_runs_the_variant_and_says_what_it_writes_it_as(desk, composed, monkeypatch):  # noqa: F811
+    monkeypatch.setenv("LITELLM_BASE_URL", "http://litellm")
+
+    result = CliRunner().invoke(cli, ["run", str(desk), "--task", "t", "--set", "driver=cua-driver", "--set",
+                                      "tools=standard", "--dry-run"])
+
+    assert result.exit_code == 0, result.output
+    assert ("--set driver=cua-driver --set tools=standard: 1 env and 1 task written under ids ending in "
+            "(driver cua-driver, tools standard)") in result.output
diff --git a/tst/unit/env/envs/test_computer_env.py b/tst/unit/env/envs/test_computer_env.py
index 0a4b03daf..ce38ea072 100644
--- a/tst/unit/env/envs/test_computer_env.py
+++ b/tst/unit/env/envs/test_computer_env.py
@@ -25,7 +25,7 @@
 from agentenv_protocol.computer import COMPUTER_DISPLAY, COMPUTER_READY, COMPUTER_RECORDING
 from agentenv_protocol.computer.app import COMPUTER_APP
 from agentenv_protocol.computer.app_runtime import HOLD_BOOT_LAUNCH_ENV
-from agentenv_protocol.tool_access import DISABLE_TOOL_EXTENSION_URI
+from agentenv_protocol.tool_access import DISABLE_TOOL_EXTENSION_URI, ENABLE_TOOL_EXTENSION_URI
 from click.testing import CliRunner
 
 from agent_env.artifact.artifacts.computer import ComputerArtifact
@@ -39,12 +39,12 @@
 from agent_env.config import get_config
 from agent_env.env import Env
 from agent_env.env import env as env_module
-from agent_env.env.env import DeployedEnv
+from agent_env.env.env import DeployedEnv, EnvCapabilityUnsupported
 from agent_env.env.envs.computer.utils import (boot, builder, composed, composer, gate, inside, packages, params,
                                                probing, resolve_in_base)
 from agent_env.env.envs.computer.utils.composer import Composing
 from agent_env.env.envs.computer.utils.probing import _probe
-from agent_env.env.envs.computer.env import ComputerEnv
+from agent_env.env.envs.computer.env import COMPUTER_TOOLS, ComputerEnv
 from agent_env.env.envs.computer import app_env
 from agent_env.env.envs.computer.app_env import ComputerAppEnv
 from agent_env.env.envs.computer.utils.install import Install, Service
@@ -474,8 +474,9 @@ async def test_a_computer_env_with_no_ready_build_is_refused_at_deploy_naming_it
      "computer_settings.wallpaper: @local/~/kit/ubuntu-24.04 declares no setting 'wallpaper'"),
     ({"computer_settings": {"timezone": 3}}, "computer_settings.timezone must be a str, like its default 'UTC', not 3"),
     ({"computer_settings": ["timezone"]}, "computer_settings must be a table of the computer's setting values"),
+    ({"tools": "all"}, "tools is 'standard', 'driver' or 'both', not 'all'"),
 ], ids=["display-zero", "display-side", "display-and-resolution", "network", "network-key",
-        "settings-name", "settings-type", "settings-table"])
+        "settings-name", "settings-type", "settings-table", "tools"])
 def test_what_the_env_declares_wrong_is_refused_before_anything_is_stored(base, driver, docker, changes, problem):
     with pytest.raises(ValueError, match="computer env '@local/~/kit/desktop'") as refused:
         _put(base, driver, **changes)
@@ -642,6 +643,7 @@ def test_builds_of_one_env_at_once_keep_each_others_pairs_and_a_failure_doesnt_r
 DRIVER_CARD = {"name": "desktop", "capabilities": {"extensions": [
     {"uri": COMPUTER_DISPLAY, "params": {"endpoint": "/computer/display", "methods": {"get": {"method": "GET"}}}},
     {"uri": DISABLE_TOOL_EXTENSION_URI, "params": {"endpoint": "/tools/disable", "methods": {"disable": {}}}},
+    {"uri": ENABLE_TOOL_EXTENSION_URI, "params": {"endpoint": "/tools/enable", "methods": {"enable": {}}}},
     {"uri": COMPUTER_RECORDING, "params": {"endpoint": "/computer/recording", "methods": {"end_all": {}}}}]}}
 
 
@@ -756,6 +758,45 @@ async def reset_container(self, sandbox, **kwargs):
     assert boots.calls == [(COMPUTER_RECORDING, "end_all", {"reason": "reset"}), "reset_container", (COMPUTER_DISPLAY, "get", None)]
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("tools, changes", [
+    ("standard", [(DISABLE_TOOL_EXTENSION_URI, "disable", {"role": "default", "tools": ["*"]}),
+                  (ENABLE_TOOL_EXTENSION_URI, "enable", {"role": "default", "tools": list(COMPUTER_TOOLS)})]),
+    ("driver", [(DISABLE_TOOL_EXTENSION_URI, "disable", {"role": "default", "tools": list(COMPUTER_TOOLS)})]),
+    ("both", []),
+])
+async def test_a_computer_envs_tools_are_given_its_agents_at_deploy_and_again_after_a_reset(
+        base, driver, docker, boots, monkeypatch, tools, changes):
+    env = _put(base, driver, display={"width": 1600, "height": 900}, tools=tools)
+    deployed = await Env.get(env.id).deploy()
+    (sandbox,) = boots.sandboxes
+    given = [call for call in boots.calls if call[0] in (DISABLE_TOOL_EXTENSION_URI, ENABLE_TOOL_EXTENSION_URI)]
+    monkeypatch.setattr(local_sandbox.LocalSandboxProvider, "get_sandbox", AsyncMock(return_value=sandbox))
+    monkeypatch.setattr(local_sandbox.LocalSandboxProvider, "reset_container", AsyncMock())
+    monkeypatch.setattr(env_computer_provider, "ready", AsyncMock(return_value=DRIVER_CARD))
+    boots.calls.clear()
+
+    await ResetEnvTaskStep(id="reset", version=None, env_id=env.id, fail_task_on_error=True).execute(
+        TaskStepContext(deployed_envs=[deployed]))
+
+    assert Env.get(env.id).tools == tools and given == changes
+    assert [call for call in boots.calls if call[0] in (DISABLE_TOOL_EXTENSION_URI, ENABLE_TOOL_EXTENSION_URI)] == changes
+
+
+@pytest.mark.asyncio
+async def test_a_deploy_whose_tools_the_driver_cant_take_fails_and_tears_the_computer_down(base, driver, docker, boots,
+                                                                                          monkeypatch):
+    monkeypatch.setitem(DRIVER_CARD["capabilities"], "extensions", [
+        extension for extension in DRIVER_CARD["capabilities"]["extensions"] if extension["uri"] != ENABLE_TOOL_EXTENSION_URI])
+    env = _put(base, driver, display={"width": 1600, "height": 900}, tools="standard")
+
+    with pytest.raises(EnvCapabilityUnsupported):
+        await Env.get(env.id).deploy()
+
+    (sandbox,) = boots.sandboxes
+    assert sandbox.terminated
+
+
 @pytest.mark.asyncio
 async def test_a_reset_a_provider_cant_carry_out_fails_the_step_rather_than_skipping_it(base, driver, docker, boots,
                                                                                        monkeypatch):

From 233b8de16f46e6f4d6367bc4f96a1dd615be2a81 Mon Sep 17 00:00:00 2001
From: Edgar Arakelyan <edgar.arakelyan@scale.com>
Date: Thu, 5 Nov 2026 15:07:29 -0800
Subject: [PATCH 2/6] fix(run): --set names its env, as envs/NAME.KEY=VALUE;
 renames key by kind; tools before register

--set takes only envs/NAME.KEY=VALUE: no kind is a default target, and other
kinds can take their own folder prefix later. The env's type checks the key
and value as it checks an env.toml's, so the toml_keys declarations the bare
form needed are gone.

Renames are keyed by kind and id, since an id is unique within its kind
alone: a skill sharing an env's id stays as it is. A --task or --eval naming
an entry by its id selects its variant. A computer env's tools are given
before the deployment is registered or replaces the last one, so a driver
that can't take them fails the deploy and leaves the earlier deployment up.

Refs FD-4362

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/agent_env/bundle/run.py                |   8 +-
 src/agent_env/bundle/variants.py           | 134 +++++++++------------
 src/agent_env/cli/run.py                   |  23 ++--
 src/agent_env/computers/README.md          |   4 +-
 src/agent_env/drivers/README.md            |   8 +-
 src/agent_env/drivers/aliases.toml         |   2 +-
 src/agent_env/env/envs/_deployment.py      |   8 +-
 src/agent_env/env/envs/computer/app_env.py |   5 +-
 src/agent_env/env/envs/computer/env.py     |   5 +-
 tst/unit/bundle/installed_test.py          |   2 +-
 tst/unit/bundle/variants_test.py           |  81 ++++++++-----
 tst/unit/env/envs/test_computer_env.py     |  13 +-
 12 files changed, 154 insertions(+), 139 deletions(-)

diff --git a/src/agent_env/bundle/run.py b/src/agent_env/bundle/run.py
index a9e485fb3..a88838990 100644
--- a/src/agent_env/bundle/run.py
+++ b/src/agent_env/bundle/run.py
@@ -46,7 +46,7 @@
 from .requires import Declaring, declare, declaring_for
 from .resolve import (BuiltImage, BundleImage, Reference, ReferencedImage, ResolvedEntry, resolve_bundle,
                       without_played_agents)
-from .variants import Variant, with_variant
+from .variants import Variant, selected, with_variant
 
 logger = logging.getLogger(__name__)
 
@@ -405,7 +405,11 @@ def _planned(root: Path | str, tasks: Sequence[str], evals: Sequence[str], id_ro
              sandbox: str | None, agent: str | None = None, *, played: bool = False,
              solver_endpoint: bool = False, variant: Variant | None = None) -> tuple[Plan, Preflight]:
     bundle = parse_bundle(Path(root), id_root=id_root)
-    resolved = resolve_bundle(with_variant(bundle, variant) if variant else bundle)
+    if variant is not None:
+        varied = with_variant(bundle, variant)
+        tasks, evals = selected(bundle, varied, tasks, BundleKind.TASK), selected(bundle, varied, evals, BundleKind.EVAL)
+        bundle = varied
+    resolved = resolve_bundle(bundle)
     plan = plan_bundle(without_played_agents(resolved) if played else resolved, tasks=tasks, evals=evals,
                        installed=installed_bundles, agent=agent)
     refuse_store_tasks(plan)
diff --git a/src/agent_env/bundle/variants.py b/src/agent_env/bundle/variants.py
index 4320625d0..9ec04e8f0 100644
--- a/src/agent_env/bundle/variants.py
+++ b/src/agent_env/bundle/variants.py
@@ -1,12 +1,13 @@
-"""Run-only variants for ``agent-env run --set KEY=VALUE``: the bundle as parsed, with env keys set for one run. Each env
-changed, each env and task that names one, and each eval that names such a task is written under a derived id, so a
-variant is written and composed beside the bundle's own. Entries keep their names, so every reference to one by name
-reaches its variant; the bundle's files stay as written."""
+"""Run-only variants for ``agent-env run --set envs/NAME.KEY=VALUE``: the bundle as parsed, with env keys set for one
+run. Each env changed, each env and task that names one, and each eval that names such a task is written under a
+derived id, so a variant is written and composed beside the bundle's own. Entries keep their names, so every reference to
+one by name reaches its variant; the bundle's files stay as written."""
 from __future__ import annotations
 
 import copy
 import hashlib
 import tomllib
+from collections.abc import Sequence
 from dataclasses import dataclass, replace
 from typing import Any
 
@@ -17,18 +18,20 @@
 from .parse import Bundle, BundleEntry, BundleError, BundleKind, segment_problem
 
 _TARGET = f"{BundleKind.ENV.value}/"
+_FORM = "envs/NAME.KEY=VALUE, such as envs/desktop.driver=cua-driver"
 
 
 @dataclass(frozen=True)
 class Variant:
-    """The ``--set`` settings of a run, as typed: ``KEY=VALUE`` for every env the bundle's tasks deploy whose type takes
-    KEY, or ``envs/NAME.KEY=VALUE`` for one env; KEY may be dotted into a table, VALUE is TOML or a bare word."""
+    """The ``--set`` settings of a run, as typed: ``envs/NAME.KEY=VALUE``, KEY of the env in folder ``envs/NAME``,
+    dotted into a table, set to VALUE, TOML or a bare word."""
 
     settings: tuple[str, ...]
 
     @property
     def label(self) -> str:
-        """The settings as ids end in them: ``driver cua-driver, display 3f2a9c1e``, a value an id can't hold hashed."""
+        """The settings as ids end in them: ``desktop.driver cua-driver, desktop.display 3f2a9c1e``, a value an id can't
+        hold hashed."""
         return ", ".join(f"{key.removeprefix(_TARGET)} {_shown(raw)}"
                          for key, raw in (setting.partition("=")[::2] for setting in self.settings))
 
@@ -40,59 +43,60 @@ def typed(self) -> str:
 
 @dataclass(frozen=True)
 class _Setting:
-    text: str
-    env: str | None  # the env it names, by name; None for every env deployed that takes path[0]
+    env: str  # the env it sets, by name
     path: tuple[str, ...]
     value: Any
 
 
 def with_variant(bundle: Bundle, variant: Variant) -> Bundle:
     """``bundle`` with ``variant``'s settings in its envs' tomls, and each entry that changes under an id ending in
-    ``(<label>)``. Raises BundleError for a setting that isn't ``KEY=VALUE``, names no env of the bundle, or that no env
-    the bundle's tasks deploy takes."""
-    envs = [entry for entry in bundle.entries if entry.kind is BundleKind.ENV]
-    settings = _parsed(variant.settings, {entry.name for entry in envs})
-    deployed = _deployed(bundle)
-    configs, problems = {}, []
-    for setting in settings:
-        hit = [entry for entry in envs if setting.env == entry.name or setting.env is None
-               and deployed & {entry.name, entry.id} and setting.path[0] in _keys(entry)]
-        if not hit:
-            problems.append(_untaken(setting, [entry for entry in envs if deployed & {entry.name, entry.id}]))
-        for entry in hit:
-            configs[entry.id] = _set(configs.get(entry.id, entry.config), setting.path, setting.value)
-    if problems:
-        raise BundleError(problems)
+    ``(<label>)``. Raises BundleError for a setting that isn't ``envs/NAME.KEY=VALUE`` or names no env of the bundle; the
+    env's type checks the key and value as it checks an env.toml's."""
+    by_name = {entry.name: entry for entry in bundle.entries if entry.kind is BundleKind.ENV}
+    configs = {}
+    for setting in _parsed(variant.settings, set(by_name)):
+        entry = by_name[setting.env]
+        configs[entry.id] = _set(configs.get(entry.id, entry.config), setting.path, setting.value)
     renamed = _renamed_ids(bundle, set(configs), variant.label)
+    envs, tasks = ({entry_id: new for (kind, entry_id), new in renamed.items() if kind is of}
+                   for of in (BundleKind.ENV, BundleKind.TASK))
     entries = []
     for entry in bundle.entries:
-        if entry.id not in renamed:
+        new_id = renamed.get((entry.kind, entry.id))
+        if new_id is None:
             entries.append(entry)
         elif entry.kind is BundleKind.ENV:
-            entries.append(_renamed(entry, renamed, _repointed_toml(entry, configs.get(entry.id, entry.config), renamed)))
+            entries.append(_renamed(entry, new_id, _repointed_toml(entry, configs.get(entry.id, entry.config), envs)))
         elif entry.kind is BundleKind.TASK:
-            entries.append(_renamed(entry, renamed, _repointed_steps(entry.config, renamed)))
+            entries.append(_renamed(entry, new_id, _repointed_steps(entry.config, envs)))
         else:
-            entries.append(_renamed(entry, renamed, _eval(entry.config, renamed)))
+            entries.append(_renamed(entry, new_id, _eval(entry.config, tasks)))
     return replace(bundle, entries=tuple(entries))
 
 
+def selected(before: Bundle, after: Bundle, names: Sequence[str], kind: BundleKind) -> tuple[str, ...]:
+    """``names``, a run's selections of ``kind`` by name or id, with the id of each entry ``after`` renames as its new
+    id."""
+    ids = {old.id: new.id for old, new in zip(before.entries, after.entries) if old.kind is kind and old.id != new.id}
+    return tuple(ids.get(name, name) for name in names)
+
+
 def _parsed(texts: tuple[str, ...], names: set[str]) -> list[_Setting]:
     settings, problems = [], []
     for text in texts:
         key, equals, raw = text.partition("=")
-        env = None
-        if key.startswith(_TARGET):
-            env = max((name for name in names if key.startswith(f"{_TARGET}{name}.")), key=len, default=None)
-            if env is None:
-                problems.append(f"--set {text}: {key.partition('.')[0]} names no env of this bundle")
-                continue
-            key = key.removeprefix(f"{_TARGET}{env}.")
-        path = tuple(key.split("."))
-        if not equals or not all(path):
-            problems.append(f"--set {text}: expected KEY=VALUE, such as driver=cua-driver")
+        if not equals or not key.startswith(_TARGET) or "." not in key:
+            problems.append(f"--set {text}: expected {_FORM}")
             continue
-        settings.append(_Setting(text, env, path, _value(raw)))
+        env = max((name for name in names if key.startswith(f"{_TARGET}{name}.")), key=len, default=None)
+        if env is None:
+            problems.append(f"--set {text}: {key.partition('.')[0]} names no env of this bundle")
+            continue
+        path = tuple(key.removeprefix(f"{_TARGET}{env}.").split("."))
+        if not all(path):
+            problems.append(f"--set {text}: expected {_FORM}")
+            continue
+        settings.append(_Setting(env, path, _value(raw)))
     if problems:
         raise BundleError(problems)
     return settings
@@ -110,23 +114,6 @@ def _shown(raw: str) -> str:
     return raw if raw and segment_problem(raw) is None else hashlib.sha256(raw.encode()).hexdigest()[:8]
 
 
-def _deployed(bundle: Bundle) -> set[str]:
-    """The envs the bundle's tasks deploy, as their steps name them."""
-    return {step["env_id"] for entry in bundle.entries if entry.kind is BundleKind.TASK for step in entry.config
-            if step.get("type") == "deploy_env" and isinstance(step.get("env_id"), str)}
-
-
-def _keys(entry: BundleEntry) -> dict[str, type]:
-    cls = get_env_registry().get(entry.type)
-    return getattr(cls, "toml_keys", None) or {}
-
-
-def _untaken(setting: _Setting, deployed: list[BundleEntry]) -> str:
-    takes = {entry.type: sorted(_keys(entry)) for entry in deployed if _keys(entry)}
-    named = "; ".join(f"a {kind} env takes {', '.join(keys)}" for kind, keys in sorted(takes.items()))
-    return f"--set {setting.text}: no env this bundle's tasks deploy takes {setting.path[0]}" + (f"; {named}" if named else "")
-
-
 def _set(config: dict, path: tuple[str, ...], value: Any) -> dict:
     config = copy.deepcopy(config)
     table = config
@@ -139,25 +126,24 @@ def _set(config: dict, path: tuple[str, ...], value: Any) -> dict:
 
 
 def _renamed_ids(bundle: Bundle, changed: set[str], label: str) -> dict[str, str]:
-    """Each id that changes, to its variant's: the envs set, each env and task naming one that changes, by name or id,
-    and each eval naming such a task."""
+    """Each entry that changes, by kind and id, to its variant's id: the envs ``changed``, each env and task naming one
+    that changes, by name or id, and each eval naming such a task. An id is unique within its kind alone."""
     by_name = {(entry.kind, entry.name): entry.id for entry in bundle.entries}
-    changing = set(changed)
-    while True:
-        more = {entry.id for entry in bundle.entries if entry.id not in changing and entry.kind in (
-            BundleKind.ENV, BundleKind.TASK) and _names_env(entry, changing, by_name)}
-        if not more:
-            break
-        changing |= more
-    tasks = {entry.id for entry in bundle.entries if entry.kind is BundleKind.TASK and entry.id in changing}
-    changing |= {entry.id for entry in bundle.entries if entry.kind is BundleKind.EVAL and any(
+    envs = set(changed)
+    while more := {entry.id for entry in bundle.entries if entry.kind is BundleKind.ENV and entry.id not in envs
+                   and _names_env(entry, envs, by_name)}:
+        envs |= more
+    tasks = {entry.id for entry in bundle.entries if entry.kind is BundleKind.TASK and _names_env(entry, envs, by_name)}
+    evals = {entry.id for entry in bundle.entries if entry.kind is BundleKind.EVAL and any(
         by_name.get((BundleKind.TASK, task), task) in tasks for task in entry.config.get("tasks") or []
         if isinstance(task, str))}
-    return {entry_id: f"{entry_id}({label})" for entry_id in changing}
+    return {(kind, entry_id): f"{entry_id}({label})"
+            for kind, ids in ((BundleKind.ENV, envs), (BundleKind.TASK, tasks), (BundleKind.EVAL, evals))
+            for entry_id in ids}
 
 
-def _names_env(entry: BundleEntry, changing: set[str], by_name: dict) -> bool:
-    return any(by_name.get((BundleKind.ENV, site.value), site.value) in changing for site in _env_sites(entry))
+def _names_env(entry: BundleEntry, envs: set[str], by_name: dict) -> bool:
+    return any(by_name.get((BundleKind.ENV, site.value), site.value) in envs for site in _env_sites(entry))
 
 
 def _env_sites(entry: BundleEntry):
@@ -173,11 +159,11 @@ def _env_sites(entry: BundleEntry):
                     if site.ref.kind is EntityKind.ENV and isinstance(site.value, str))
 
 
-def _renamed(entry: BundleEntry, renamed: dict[str, str], config: Any) -> BundleEntry:
-    """``entry`` under its variant's id with ``config``, whose declared id, when it has one, is that id too."""
+def _renamed(entry: BundleEntry, new_id: str, config: Any) -> BundleEntry:
+    """``entry`` under ``new_id`` with ``config``, whose declared id, when it has one, is that id too."""
     if isinstance(config, dict) and "id" in config:
-        config = {**config, "id": renamed[entry.id]}
-    return replace(entry, id=renamed[entry.id], config=config)
+        config = {**config, "id": new_id}
+    return replace(entry, id=new_id, config=config)
 
 
 def _repointed_toml(entry: BundleEntry, config: dict, renamed: dict[str, str]) -> dict:
diff --git a/src/agent_env/cli/run.py b/src/agent_env/cli/run.py
index d9282b969..5052e5209 100644
--- a/src/agent_env/cli/run.py
+++ b/src/agent_env/cli/run.py
@@ -43,10 +43,10 @@
 @click.option("--agent", default=None,
               help="The agent the solver runs as, whatever the tasks name: an alias such as pi, an agent of this "
                    "bundle or an installed one, or the store's.")
-@click.option("--set", "settings", multiple=True, metavar="KEY=VALUE",
-              help="Set an env key for this run, whatever the bundle's env.toml files say: in every env the tasks "
-                   "deploy whose type takes KEY, or in one as envs/NAME.KEY=VALUE. VALUE is TOML or a bare word, and "
-                   "KEY may be dotted into a table. Repeatable. Such as driver=cua-driver or tools=standard.")
+@click.option("--set", "settings", multiple=True, metavar="envs/NAME.KEY=VALUE",
+              help="Set a key of one of the bundle's envs for this run, as envs/NAME.KEY=VALUE, whatever its env.toml "
+                   "says: VALUE is TOML or a bare word, and KEY may be dotted into a table. Repeatable. Such as "
+                   "envs/desktop.driver=cua-driver or envs/desktop.tools=standard.")
 @click.option("--sandbox", default=None,
               help="The sandbox provider envs, agents, sandboxes and the judge deploy on, which picks the forms "
                    "computer envs compose on this machine; comma-separated for a fallback chain.")
@@ -84,13 +84,14 @@ def run(ctx: click.Context, bundle: str | None, tasks: tuple[str, ...], evals: t
     agent the solver runs as: each step that deploys or installs the agent a task prompts deploys it instead,
     while its user simulator and judges keep theirs.
 
-    --set sets env keys for this run, as the env.toml files would: --set driver=cua-driver runs every computer env
-    the tasks deploy with that driver, and --set envs/desktop.computer=ubuntu-24.04-headless composes one on that
-    base. The envs it changes, the envs and tasks that name them and the evals that name those tasks are written
-    under ids of their own, ending in the settings, such as desktop(driver cua-driver), and compose and reuse their
-    images as any env does, leaving the bundle as written. A key no env the tasks deploy takes, or a value the env's
-    type refuses, is refused before anything is written; a driver and computer that can't compose, as the run writes
-    the env, before any task runs.
+    --set sets a key of one of the bundle's envs for this run, as its env.toml would: --set
+    envs/desktop.driver=cua-driver runs the env in envs/desktop with that driver, and --set
+    envs/desktop.computer=ubuntu-24.04-headless composes it on that base. The envs it changes, the envs and tasks
+    that name them and the evals that name those tasks are written under ids of their own, ending in the settings,
+    such as desktop(desktop.driver cua-driver), and compose and reuse their images as any env does, leaving the
+    bundle as written. A key or value the env's type refuses, or a run whose tasks deploy no env it changes, is
+    refused before anything is written; a driver and computer that can't compose, as the run writes the env, before
+    any task runs.
 
     --dry-run makes the checks the run makes before its first task, reading the stores as the run does, and
     prints what it would write and run, writing and running nothing. It exits 1 on a problem the run would
diff --git a/src/agent_env/computers/README.md b/src/agent_env/computers/README.md
index fc4fb5a78..b6572c071 100644
--- a/src/agent_env/computers/README.md
+++ b/src/agent_env/computers/README.md
@@ -1,6 +1,6 @@
 Base computers that come with agent-env, each a `computer` artifact a computer env composes a driver and apps onto.
-`agent-env run <bundle> --set computer=ubuntu-24.04-headless` composes a bundle's computer envs on another of them
-for one run, the bundle left as written.
+`agent-env run <bundle> --set envs/desktop.computer=ubuntu-24.04-headless` composes a bundle's `desktop` env on
+another of them for one run, the bundle left as written.
 
 `artifacts/ubuntu-24.04/` is Ubuntu 24.04 (`amd64` and `arm64`) with XFCE on Xvfb, D-Bus and AT-SPI. tini starts
 supervisord, which runs every program as the session user, `user` (uid 1000); nothing in it runs as root. Its home
diff --git a/src/agent_env/drivers/README.md b/src/agent_env/drivers/README.md
index 26c7272bb..23806bb06 100644
--- a/src/agent_env/drivers/README.md
+++ b/src/agent_env/drivers/README.md
@@ -1,9 +1,9 @@
 Computer drivers that come with agent-env, each a `computer_driver` env a computer env serves its tools through.
 A computer env's `tools` is what its agents get: `standard`, AgentEnv's `computer_*` tools alone;
-`driver`, the driver's own alone; or `both`, the default. `agent-env run <bundle> --set driver=cua-driver` runs a
-bundle's computer envs with another driver for one run, and `--set tools=driver` gives their agents the driver's own
-tools; the bundle stays as written, and what changes is written under ids ending in the settings, such as
-`desktop(driver cua-driver)`.
+`driver`, the driver's own alone; or `both`, the default. `agent-env run <bundle> --set envs/desktop.driver=cua-driver`
+runs a bundle's `desktop` env with another driver for one run, and `--set envs/desktop.tools=driver` gives its agents
+the driver's own tools; the bundle stays as written, and what changes is written under ids ending in the settings,
+such as `desktop(desktop.driver cua-driver)`.
 
 `envs/reference/` is the reference driver, for an X11 desktop on Linux (`amd64` and `arm64`): `mss` captures the
 screen and XTEST, through `python-xlib`, sends the input, foreground only. It serves the seven `computer_*` tools, the
diff --git a/src/agent_env/drivers/aliases.toml b/src/agent_env/drivers/aliases.toml
index df418f49f..f53cc16c2 100644
--- a/src/agent_env/drivers/aliases.toml
+++ b/src/agent_env/drivers/aliases.toml
@@ -1,4 +1,4 @@
-# Ids a task, or --set driver=, can name these drivers by; a store's env of the id wins over an alias.
+# Ids a task, or --set envs/<name>.driver=, can name these drivers by; a store's env of the id wins over an alias.
 [envs]
 reference = ["reference"]
 cua-driver = ["cua-driver"]
diff --git a/src/agent_env/env/envs/_deployment.py b/src/agent_env/env/envs/_deployment.py
index 3c9138320..95c8450c6 100644
--- a/src/agent_env/env/envs/_deployment.py
+++ b/src/agent_env/env/envs/_deployment.py
@@ -34,8 +34,8 @@
 async def deploy_through_provider(env: Env, *, environment_name: str | None, ttl_seconds: int, sandbox_type: str | None,
                                   then: Callable[[DeployedEnv], Awaitable[None]] | None = None,
                                   **options) -> DeployedEnv:
-    """Deploy env through the provider its env_provider_type names and register the record, the way each built-in env deploys,
-    then await ``then`` on it, whose failure fails the deploy.
+    """Deploy env through the provider its env_provider_type names, await ``then`` on the deployment, whose failure fails the
+    deploy, and register the record, the way each built-in env deploys.
 
     The env's provider deploys it the first time; a deploy of an env that already has a deployment gets a provider of its own,
     so that a failure closes only what it started and leaves the earlier deployment as it was. A deploy onto the env state
@@ -71,11 +71,11 @@ async def deploy_through_provider(env: Env, *, environment_name: str | None, ttl
         else:
             check_plugin_record(env, deployed)
         env._gateway_url = gateway_url_of(deployed)
+        if then is not None:
+            await then(deployed)
         deployed = register_env_instance(deployed, ttl_seconds)
         env._instance_id = deployed.instance_id
         env._deployed, env._replaced = deployed, replaced
-        if then is not None:
-            await then(deployed)
         return deployed
     except BaseException:
         try:
diff --git a/src/agent_env/env/envs/computer/app_env.py b/src/agent_env/env/envs/computer/app_env.py
index 499fee7d1..bb339b346 100644
--- a/src/agent_env/env/envs/computer/app_env.py
+++ b/src/agent_env/env/envs/computer/app_env.py
@@ -34,8 +34,6 @@ class ComputerAppEnv(ComputerEnv):
     type: ClassVar[str] = APP_TYPE
     description = ("A computer app: software and its settings on a computer, read from its ComputerAppEnvironment "
                    "class at put; deployed alone, a computer of its own")
-    toml_keys: ClassVar[dict[str, type]] = {"environment_name": str, "module": str, "computer": object, "driver": object,
-                                            "build_settings": dict, "settings": dict}
 
     def __init__(self, id: str, version: Optional[int], environment_name: str, module: str, files: FileArtifactUniverse,
                  declaration: AppDeclaration, computer: Optional[ComputerArtifact] = None,
@@ -168,7 +166,8 @@ def accept_toml(cls, data: dict, ctx: AuthoringContext) -> dict:
         its folder; ``environment_name``, the folder's when it sets none; the ``computer`` and ``driver`` it deploys
         alone on; ``build_settings``, the values of its build settings; and ``settings``, defaults for some of its
         settings that a deploy's ``env_params`` override field by field. Raises BundleError listing every problem."""
-        fields, refused = ctx.accepted(data, **cls.toml_keys)
+        fields, refused = ctx.accepted(data, environment_name=str, module=str, computer=object, driver=object,
+                                       build_settings=dict, settings=dict)
         files, module, problems = ctx.files(), fields.get("module"), []
         if module is None and "module" not in data:
             problems.append('module is required: the app\'s file and class, such as "app.py:MailApp"')
diff --git a/src/agent_env/env/envs/computer/env.py b/src/agent_env/env/envs/computer/env.py
index ecbda1aaa..211ccca72 100644
--- a/src/agent_env/env/envs/computer/env.py
+++ b/src/agent_env/env/envs/computer/env.py
@@ -77,8 +77,6 @@ class ComputerEnv(Env):
                                                   EntityRef.env("driver", env_type=ComputerDriverEnv.type),
                                                   EntityRef.env("apps[]", env_type=APP_TYPE,
                                                                 beside=("install", "settings")))
-    toml_keys: ClassVar[dict[str, type]] = {"environment_name": str, "computer": object, "driver": object, "apps": list,
-                                            "display": dict, "network": dict, "computer_settings": dict, "tools": str}
 
     def __init__(self, id: str, version: Optional[int], environment_name: str, computer: ComputerArtifact,
                  driver: ComputerDriverEnv, display: Optional[dict] = None, network: Optional[dict] = None,
@@ -169,7 +167,8 @@ def accept_toml(cls, data: dict, ctx: AuthoringContext) -> dict:
         """The keys of ``data``, an env.toml, a computer env takes: the ``computer`` and ``driver`` it's composed of,
         both required, its ``apps``, ``display``, ``network``, ``computer_settings`` and ``tools``, and
         ``environment_name``, the folder's when it sets none. Raises BundleError listing every problem."""
-        fields, refused = ctx.accepted(data, **cls.toml_keys)
+        fields, refused = ctx.accepted(data, environment_name=str, computer=object, driver=object, apps=list,
+                                       display=dict, network=dict, computer_settings=dict, tools=str)
         missing = [ctx.config_problem(f"{key} is required: the {what}, such as {example}") for key, what, example in (
             ("computer", "base computer", '"ubuntu-24.04"'), ("driver", "driver", '"reference"')) if key not in data]
         refused += [ctx.config_problem(problem) for problem in _tools_problems(fields.get("tools"))]
diff --git a/tst/unit/bundle/installed_test.py b/tst/unit/bundle/installed_test.py
index 9f2197251..64ff8c1d5 100644
--- a/tst/unit/bundle/installed_test.py
+++ b/tst/unit/bundle/installed_test.py
@@ -281,7 +281,7 @@ def test_the_cli_says_so_when_no_bundles_are_installed_and_needs_a_bundle_for_it
 
     assert CliRunner().invoke(cli, ["run"]).output == "No bundles are installed. agent-env run PATH runs a folder.\n"
     for option in (["--task", "t"], ["--keep"], ["--dry-run"], ["--user-model", "m"], ["--judge-model", "m"],
-                   ["--agent", "pi"], ["--set", "driver=reference"], ["--no-emulate"]):
+                   ["--agent", "pi"], ["--set", "envs/desktop.driver=reference"], ["--no-emulate"]):
         usage = CliRunner().invoke(cli, ["run", *option])
         assert usage.exit_code == 2
         assert ("--task, --eval, --model, --user-model, --judge-model, --agent, --set, --sandbox, --keep, --dry-run "
diff --git a/tst/unit/bundle/variants_test.py b/tst/unit/bundle/variants_test.py
index 5e0bc496b..d660372e8 100644
--- a/tst/unit/bundle/variants_test.py
+++ b/tst/unit/bundle/variants_test.py
@@ -1,4 +1,4 @@
-"""``--set KEY=VALUE``: a run's envs with keys set for that run alone, each env that changes, each env and task naming
+"""``--set envs/NAME.KEY=VALUE``: a run's envs with keys set for that run alone, each env that changes, each env and task naming
 one and each eval naming such a task under an id ending in the settings, with the bundle as written."""
 
 import json
@@ -52,21 +52,32 @@ def _ids(bundle):
 def test_a_key_set_renames_the_env_and_what_uses_it_and_leaves_the_rest(tmp_path):
     root = _bundle(tmp_path / "desk")
 
-    bundle = _varied(root, "driver=cua-driver")
+    bundle = _varied(root, "envs/desktop.driver=cua-driver")
 
-    assert _ids(bundle) == {"desktop": f"{ROOT}/desktop(driver cua-driver)", "t": f"{ROOT}/t(driver cua-driver)",
-                            "chat": f"{ROOT}/chat", "e": f"{ROOT}/e(driver cua-driver)", "chats": f"{ROOT}/chats"}
+    label = "desktop.driver cua-driver"
+    assert _ids(bundle) == {"desktop": f"{ROOT}/desktop({label})", "t": f"{ROOT}/t({label})", "chat": f"{ROOT}/chat",
+                            "e": f"{ROOT}/e({label})", "chats": f"{ROOT}/chats"}
     assert _entry(bundle, "desktop").config == {**_entry(parse_bundle(root), "desktop").config, "driver": "cua-driver"}
     assert _entry(bundle, "t").config == [DEPLOY, AGENT, PROMPT]
 
 
+def test_an_entry_of_another_kind_with_the_envs_id_stays_as_it_is(tmp_path):
+    root = _bundle(tmp_path / "desk", files={"skills/desktop/SKILL.md": "---\nname: desktop\ndescription: d\n---\n"})
+
+    bundle = _varied(root, "envs/desktop.driver=cua-driver")
+
+    skill = next(entry for entry in bundle.entries if entry.kind.value == "skills")
+    assert skill == next(entry for entry in parse_bundle(root).entries if entry.kind.value == "skills")
+    assert _entry(bundle, "t").id == f"{ROOT}/t(desktop.driver cua-driver)"
+
+
 def test_a_reference_by_id_is_repointed_at_the_variant(tmp_path):
     steps = [{**DEPLOY, "env_id": f"{ROOT}/desktop"}, {**AGENT, "env_ids": [f"{ROOT}/desktop"]}, PROMPT]
     root = _bundle(tmp_path / "desk", steps, {"evals/e.toml": f'tasks = ["{ROOT}/t"]\n'})
 
-    bundle = _varied(root, "computer=ubuntu-24.04-headless", "tools=standard")
+    bundle = _varied(root, "envs/desktop.computer=ubuntu-24.04-headless", "envs/desktop.tools=standard")
 
-    label = "computer ubuntu-24.04-headless, tools standard"
+    label = "desktop.computer ubuntu-24.04-headless, desktop.tools standard"
     assert [step.get("env_id") or step.get("env_ids") for step in _entry(bundle, "t").config] == [
         f"{ROOT}/desktop({label})", [f"{ROOT}/desktop({label})"], None]
     assert _entry(bundle, "e").config["tasks"] == [f"{ROOT}/t({label})"]
@@ -74,7 +85,7 @@ def test_a_reference_by_id_is_repointed_at_the_variant(tmp_path):
 
 
 def test_a_value_is_toml_or_a_bare_word_and_a_key_may_be_dotted_into_a_table(tmp_path):
-    settings = ("display={ width = 1280, height = 720 }", "computer_settings.theme=dark",
+    settings = ("envs/desktop.display={ width = 1280, height = 720 }", "envs/desktop.computer_settings.theme=dark",
                 "envs/desktop.network.mode=allow_all")
 
     bundle = _varied(_bundle(tmp_path / "desk"), *settings)
@@ -83,8 +94,9 @@ def test_a_value_is_toml_or_a_bare_word_and_a_key_may_be_dotted_into_a_table(tmp
     assert (config["display"], config["computer_settings"], config["network"]) == (
         {"width": 1280, "height": 720}, {"timezone": "Europe/Paris", "theme": "dark"}, {"mode": "allow_all"})
     hashed = Variant(settings).label.split(",")[0]
-    assert hashed.startswith("display ") and len(hashed) == len("display ") + 8
-    assert _entry(bundle, "desktop").id == f"{ROOT}/desktop({hashed}, computer_settings.theme dark, desktop.network.mode allow_all)"
+    assert hashed.startswith("desktop.display ") and len(hashed) == len("desktop.display ") + 8
+    assert _entry(bundle, "desktop").id == (f"{ROOT}/desktop({hashed}, desktop.computer_settings.theme dark, "
+                                            "desktop.network.mode allow_all)")
 
 
 def test_one_env_is_set_by_its_folder_and_an_env_composing_an_app_set_is_renamed_too(tmp_path):
@@ -103,13 +115,14 @@ def test_one_env_is_set_by_its_folder_and_an_env_composing_an_app_set_is_renamed
 
 
 @pytest.mark.parametrize("setting, problem", [
-    ("drivr=x", "--set drivr=x: no env this bundle's tasks deploy takes drivr; a computer env takes apps, computer, "
-                "computer_settings, display, driver, environment_name, network, tools"),
+    ("driver=cua-driver", "--set driver=cua-driver: expected envs/NAME.KEY=VALUE, such as envs/desktop.driver=cua-driver"),
+    ("envs/desktop.driver", "--set envs/desktop.driver: expected envs/NAME.KEY=VALUE, such as "
+                            "envs/desktop.driver=cua-driver"),
+    ("envs/desktop=x", "--set envs/desktop=x: expected envs/NAME.KEY=VALUE, such as envs/desktop.driver=cua-driver"),
+    ("envs/desktop.=x", "--set envs/desktop.=x: expected envs/NAME.KEY=VALUE, such as envs/desktop.driver=cua-driver"),
     ("envs/nope.driver=x", "--set envs/nope.driver=x: envs/nope names no env of this bundle"),
-    ("driver", "--set driver: expected KEY=VALUE, such as driver=cua-driver"),
-    ("=x", "--set =x: expected KEY=VALUE, such as driver=cua-driver"),
 ])
-def test_a_setting_no_env_can_take_is_refused(tmp_path, setting, problem):
+def test_a_setting_that_names_no_envs_key_is_refused(tmp_path, setting, problem):
     with pytest.raises(BundleError) as refused:
         _varied(_bundle(tmp_path / "desk"), setting)
 
@@ -127,26 +140,31 @@ def _plan(root, *settings):
 
 
 def test_the_variant_is_written_and_composed_with_its_driver_beside_the_bundles_own(desk, composed):  # noqa: F811
-    plan = _plan(desk, "driver=cua-driver", "tools=driver")
+    plan = _plan(desk, "envs/desktop.driver=cua-driver", "envs/desktop.tools=driver")
 
     materialize(plan, build_here=local_builds(plan))
 
-    env = Env.get(f"{ROOT}/desktop(driver cua-driver, tools driver)")
+    env = Env.get(f"{ROOT}/desktop(desktop.driver cua-driver, desktop.tools driver)")
     assert (env.computer.id, env.driver.id, env.environment_name, env.tools) == (UBUNTU, CUA, "desktop", "driver")
     assert composed == [(env.id, UBUNTU, CUA, None)]
     assert (desk / "envs/desktop/env.toml").read_text() == DESKTOP
 
 
-def test_a_value_the_envs_type_refuses_is_refused_before_anything_is_written(desk, composed):  # noqa: F811
+@pytest.mark.parametrize("setting, problem", [
+    ("envs/desktop.tools=all", "tools is 'standard', 'driver' or 'both', not 'all'"),
+    ("envs/desktop.drivr=x", "unknown key 'drivr'; a computer env takes environment_name, computer, driver, apps, "
+                             "display, network, computer_settings, tools, type and id"),
+])
+def test_a_key_or_value_the_envs_type_refuses_is_refused_before_anything_is_written(desk, composed,  # noqa: F811
+                                                                                     setting, problem):
     with pytest.raises(BundleError) as refused:
-        dry_run_bundle(desk, variant=Variant(("tools=all",)))
+        dry_run_bundle(desk, variant=Variant((setting,)))
 
-    assert any(line.startswith("envs/desktop") and "tools is 'standard', 'driver' or 'both', not 'all'" in line
-               for line in refused.value.problems), refused.value
+    assert any(line.startswith("envs/desktop") and problem in line for line in refused.value.problems), refused.value
 
 
 def test_a_driver_that_cant_compose_with_the_computer_is_refused_as_its_written(desk, composed):  # noqa: F811
-    plan = _plan(desk, "driver=macos-harness")
+    plan = _plan(desk, "envs/desktop.driver=macos-harness")
 
     with pytest.raises(BundleError) as refused:
         materialize(plan, build_here=local_builds(plan))
@@ -158,18 +176,25 @@ def test_a_driver_that_cant_compose_with_the_computer_is_refused_as_its_written(
 
 def test_a_run_whose_tasks_deploy_nothing_its_settings_change_is_refused(desk, composed):  # noqa: F811
     with pytest.raises(BundleError) as refused:
-        dry_run_bundle(desk, tasks=["chat"], variant=Variant(("driver=cua-driver",)))
+        dry_run_bundle(desk, tasks=["chat"], variant=Variant(("envs/desktop.driver=cua-driver",)))
+
+    assert refused.value.problems == ("--set envs/desktop.driver=cua-driver: none of the tasks this run selects "
+                                      "deploys an env it changes",)
+
+
+@pytest.mark.parametrize("selection", ["t", f"{ROOT}/t"], ids=["name", "id"])
+def test_a_task_is_selected_by_its_name_or_its_id_as_the_bundle_gives_it(desk, composed, selection):  # noqa: F811
+    dry = dry_run_bundle(desk, tasks=[selection], variant=Variant(("envs/desktop.driver=cua-driver",)))
 
-    assert refused.value.problems == ("--set driver=cua-driver: none of the tasks this run selects deploys an env it "
-                                      "changes",)
+    assert [entry.id for entry in dry.runs] == [f"{ROOT}/t(desktop.driver cua-driver)"]
 
 
 def test_the_cli_runs_the_variant_and_says_what_it_writes_it_as(desk, composed, monkeypatch):  # noqa: F811
     monkeypatch.setenv("LITELLM_BASE_URL", "http://litellm")
 
-    result = CliRunner().invoke(cli, ["run", str(desk), "--task", "t", "--set", "driver=cua-driver", "--set",
-                                      "tools=standard", "--dry-run"])
+    result = CliRunner().invoke(cli, ["run", str(desk), "--task", "t", "--set", "envs/desktop.driver=cua-driver",
+                                      "--set", "envs/desktop.tools=standard", "--dry-run"])
 
     assert result.exit_code == 0, result.output
-    assert ("--set driver=cua-driver --set tools=standard: 1 env and 1 task written under ids ending in "
-            "(driver cua-driver, tools standard)") in result.output
+    assert ("--set envs/desktop.driver=cua-driver --set envs/desktop.tools=standard: 1 env and 1 task written under ids "
+            "ending in (desktop.driver cua-driver, desktop.tools standard)") in result.output
diff --git a/tst/unit/env/envs/test_computer_env.py b/tst/unit/env/envs/test_computer_env.py
index ce38ea072..11856ee69 100644
--- a/tst/unit/env/envs/test_computer_env.py
+++ b/tst/unit/env/envs/test_computer_env.py
@@ -784,17 +784,18 @@ async def test_a_computer_envs_tools_are_given_its_agents_at_deploy_and_again_af
 
 
 @pytest.mark.asyncio
-async def test_a_deploy_whose_tools_the_driver_cant_take_fails_and_tears_the_computer_down(base, driver, docker, boots,
-                                                                                          monkeypatch):
+async def test_a_deploy_whose_tools_the_driver_cant_take_fails_and_tears_down_its_computer_alone(
+        base, driver, docker, boots, monkeypatch):
+    live = Env.get(_put(base, driver, display={"width": 1600, "height": 900}, tools="standard").id)
+    first = await live.deploy()
     monkeypatch.setitem(DRIVER_CARD["capabilities"], "extensions", [
         extension for extension in DRIVER_CARD["capabilities"]["extensions"] if extension["uri"] != ENABLE_TOOL_EXTENSION_URI])
-    env = _put(base, driver, display={"width": 1600, "height": 900}, tools="standard")
 
     with pytest.raises(EnvCapabilityUnsupported):
-        await Env.get(env.id).deploy()
+        await live.deploy()
 
-    (sandbox,) = boots.sandboxes
-    assert sandbox.terminated
+    kept, failed = boots.sandboxes
+    assert failed.terminated and not kept.terminated and live._deployed is first
 
 
 @pytest.mark.asyncio

From b352359bc20542f396ba9e24da8730511987d7da Mon Sep 17 00:00:00 2001
From: Edgar Arakelyan <edgar.arakelyan@scale.com>
Date: Thu, 5 Nov 2026 16:00:52 -0800
Subject: [PATCH 3/6] refactor(run): the plan carries what --set renamed; one
 walk over an entry's env refs

with_variant returns the variant with its rename map, which the plan carries
beside --agent's override: the plan line, the refusal of a selection that
deploys nothing changed, and --task or --eval by id read it instead of
matching id suffixes or zipping entries. Finding and rewriting an entry's env
references share one walk. The bundle tests' composed fixture moves to their
conftest, and store_agent to _support, in place of two copies.

Refs FD-4362

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/agent_env/bundle/plan.py                |  2 +
 src/agent_env/bundle/register.py            |  2 +-
 src/agent_env/bundle/run.py                 | 36 +++++----
 src/agent_env/bundle/variants.py            | 87 ++++++++++-----------
 tst/unit/bundle/_support.py                 | 11 +++
 tst/unit/bundle/agent_override_test.py      | 31 +++-----
 tst/unit/bundle/computer_env_folder_test.py | 17 ----
 tst/unit/bundle/conftest.py                 | 20 +++++
 tst/unit/bundle/installed_entities_test.py  | 17 ++--
 tst/unit/bundle/variants_test.py            | 30 +++----
 10 files changed, 126 insertions(+), 127 deletions(-)

diff --git a/src/agent_env/bundle/plan.py b/src/agent_env/bundle/plan.py
index 4dda85f85..9ec3aca68 100644
--- a/src/agent_env/bundle/plan.py
+++ b/src/agent_env/bundle/plan.py
@@ -66,6 +66,7 @@
 from ._fs import fold, relative, with_article
 from .authoring import AuthoringContext, entry_files, staged_build_context
 from .parse import NAMED_BY, Bundle, BundleEntry, BundleError, BundleKind, parse_bundle
+from .variants import Varied
 from .resolve import (BuiltImage, BundleImage, Reference, ResolvedBundle, ResolvedEntry, build_step, entity_class,
                       resolve_bundle)
 
@@ -194,6 +195,7 @@ class Plan:
     # Each alias the run names, by the kind it names and then by alias.
     alias_uses: Mapping[EntityKind, Mapping[str, AliasUse]] = field(default_factory=dict)
     agent: AgentOverride | None = None  # the agent --agent names for the solver
+    variant: Varied | None = None  # what --set changes, written under its variant's ids
 
     def bundle_of(self, entry: BundleEntry) -> Bundle:
         """The bundle ``entry`` comes from: the installed one for an entry pulled in from one, else the run's."""
diff --git a/src/agent_env/bundle/register.py b/src/agent_env/bundle/register.py
index c65abfaa1..ca983e069 100644
--- a/src/agent_env/bundle/register.py
+++ b/src/agent_env/bundle/register.py
@@ -225,7 +225,7 @@ def _slug(name: str) -> str:
 
 # The fields of a Plan that hold no ``@local`` id, so a translated plan keeps them: the store's latest versions, by store
 # id, and the agent ``--agent`` names, which a registration plans without.
-_KEPT = frozenset({"store_latest", "agent"})
+_KEPT = frozenset({"store_latest", "agent", "variant"})
 
 
 def translated(plan: Plan, ids: Mapping[str, str]) -> Plan:
diff --git a/src/agent_env/bundle/run.py b/src/agent_env/bundle/run.py
index a88838990..0ad85b9f4 100644
--- a/src/agent_env/bundle/run.py
+++ b/src/agent_env/bundle/run.py
@@ -46,7 +46,7 @@
 from .requires import Declaring, declare, declaring_for
 from .resolve import (BuiltImage, BundleImage, Reference, ReferencedImage, ResolvedEntry, resolve_bundle,
                       without_played_agents)
-from .variants import Variant, selected, with_variant
+from .variants import Variant, with_variant
 
 logger = logging.getLogger(__name__)
 
@@ -359,7 +359,7 @@ def dry_run_bundle(
     say = _progress(on_progress)
     with namespace_routing():
         plan, preflight = _planned(root, tasks, evals, id_root, sandbox, agent, variant=variant)
-        _say_plan(plan, say, declaring_for(Path(root), installed=id_root is not None, dry_run=True), variant)
+        _say_plan(plan, say, declaring_for(Path(root), installed=id_root is not None, dry_run=True))
         materialization = materialize(plan, dry_run=True, on_write=lambda done: say(_written(plan, done)),
                                       composing=composing, sandbox=sandbox,
                                       on_progress=lambda write, line: say(f"{_label(plan, write)}: {line}"))
@@ -395,7 +395,7 @@ def _prepare(root: Path | str, tasks: Sequence[str], evals: Sequence[str], sandb
              variant: Variant | None = None) -> PreparedBundle:
     plan, preflight = _planned(root, tasks, evals, id_root, sandbox, agent, played=played,
                                solver_endpoint=solver_endpoint, variant=variant)
-    _say_plan(plan, say, declaring, variant)
+    _say_plan(plan, say, declaring)
     materialization = _written_with_infra(plan, preflight, say, composing, sandbox)
     to_run = tuple((entry, Task.get(entry.id, materialization.version_of("task", entry.id))) for entry in _to_run(plan))
     return PreparedBundle(plan, materialization, to_run)
@@ -405,16 +405,17 @@ def _planned(root: Path | str, tasks: Sequence[str], evals: Sequence[str], id_ro
              sandbox: str | None, agent: str | None = None, *, played: bool = False,
              solver_endpoint: bool = False, variant: Variant | None = None) -> tuple[Plan, Preflight]:
     bundle = parse_bundle(Path(root), id_root=id_root)
-    if variant is not None:
-        varied = with_variant(bundle, variant)
-        tasks, evals = selected(bundle, varied, tasks, BundleKind.TASK), selected(bundle, varied, evals, BundleKind.EVAL)
-        bundle = varied
-    resolved = resolve_bundle(bundle)
+    varied = with_variant(bundle, variant) if variant is not None else None
+    if varied is not None:
+        tasks, evals = varied.selected(tasks, BundleKind.TASK), varied.selected(evals, BundleKind.EVAL)
+    resolved = resolve_bundle(varied.bundle if varied is not None else bundle)
     plan = plan_bundle(without_played_agents(resolved) if played else resolved, tasks=tasks, evals=evals,
                        installed=installed_bundles, agent=agent)
     refuse_store_tasks(plan)
-    if variant is not None and not _changed(plan, variant):
-        raise BundleError([f"{variant.typed}: none of the tasks this run selects deploys an env it changes"])
+    if varied is not None:
+        plan = replace(plan, variant=varied)
+        if not _changed(plan):
+            raise BundleError([f"{variant.typed}: none of the tasks this run selects deploys an env it changes"])
     to_run = set(_to_run(plan))
     return plan, preflight_run(plan, [write.source for write in plan.writes
                                       if write.kind is BundleKind.TASK and write.source.entry in to_run], sandbox,
@@ -465,9 +466,9 @@ def refuse_store_tasks(plan: Plan) -> None:
         raise BundleError(problems)
 
 
-def _say_plan(plan: Plan, say: Callable[[str], None], declaring: Declaring, variant: Variant | None = None) -> None:
+def _say_plan(plan: Plan, say: Callable[[str], None], declaring: Declaring) -> None:
     """Say what each agent, env and artifact alias names, what the solver deploys in place of the tasks' agents, the
-    ids ``variant``'s entries are written under, and what plugin packages the bundle uses that its bundle.toml doesn't
+    ids what --set changes is written under, and what plugin packages the bundle uses that its bundle.toml doesn't
     require, as ``declaring`` says (``declare``)."""
     for use in (use for uses in plan.alias_uses.values() for use in uses.values()):
         say(_aliased(use))
@@ -476,16 +477,17 @@ def _say_plan(plan: Plan, say: Callable[[str], None], declaring: Declaring, vari
         solved = sum(entry.id in plan.agent.steps for entry in runs)
         say(f"--agent {plan.agent.name}: the solver deploys {plan.agent.agent_id}, in {solved} of {len(runs)} "
             f"task{'s' if len(runs) != 1 else ''}")
-    if variant is not None:
-        say(f"{variant.typed}: {_changed(plan, variant)} written under ids ending in ({variant.label})")
+    if plan.variant is not None:
+        variant = plan.variant.variant
+        say(f"{variant.typed}: {_changed(plan)} written under ids ending in ({variant.label})")
     for line in declare(plan.bundle, declaring):
         say(line)
 
 
-def _changed(plan: Plan, variant: Variant) -> str:
-    """How many envs, tasks and evals ``variant`` changes the run writes: ``1 env and 2 tasks``, or ``""``."""
+def _changed(plan: Plan) -> str:
+    """How many envs, tasks and evals that --set changes the run writes: ``1 env and 2 tasks``, or ``""``."""
     counts = Counter(write.kind for write in plan.writes
-                     if isinstance(write.source, ResolvedEntry) and write.id.endswith(f"({variant.label})"))
+                     if isinstance(write.source, ResolvedEntry) and plan.variant.changes(write.kind, write.id))
     named = [f"{counts[kind]} {noun}{'s' if counts[kind] != 1 else ''}" for kind, noun in (
         (BundleKind.ENV, "env"), (BundleKind.TASK, "task"), (BundleKind.EVAL, "eval")) if counts[kind]]
     return " and ".join([", ".join(named[:-1]), named[-1]] if len(named) > 1 else named)
diff --git a/src/agent_env/bundle/variants.py b/src/agent_env/bundle/variants.py
index 9ec04e8f0..59701ed81 100644
--- a/src/agent_env/bundle/variants.py
+++ b/src/agent_env/bundle/variants.py
@@ -7,11 +7,11 @@
 import copy
 import hashlib
 import tomllib
-from collections.abc import Sequence
+from collections.abc import Iterator, Mapping, Sequence
 from dataclasses import dataclass, replace
 from typing import Any
 
-from agent_env.entity.refs import EntityKind, ref_sites
+from agent_env.entity.refs import EntityKind, EntityRef, RefSite, ref_sites
 from agent_env.env.registry import get_env_registry
 from agent_env.task_step.registry import get_task_step_registry
 
@@ -41,6 +41,24 @@ def typed(self) -> str:
         return " ".join(f"--set {setting}" for setting in self.settings)
 
 
+@dataclass(frozen=True)
+class Varied:
+    """A bundle with a variant's settings: ``bundle``, and ``renamed``, each entry it changes, by kind and id, to its
+    variant's id."""
+
+    variant: Variant
+    bundle: Bundle
+    renamed: Mapping[tuple[BundleKind, str], str]
+
+    def changes(self, kind: BundleKind, entry_id: str) -> bool:
+        """Whether ``entry_id`` is the variant's id of an entry of ``kind`` it changes."""
+        return entry_id in {new for (of, _), new in self.renamed.items() if of is kind}
+
+    def selected(self, names: Sequence[str], kind: BundleKind) -> tuple[str, ...]:
+        """``names``, a run's selections of ``kind`` by name or id, each id of an entry it changes as its variant's."""
+        return tuple(self.renamed.get((kind, name), name) for name in names)
+
+
 @dataclass(frozen=True)
 class _Setting:
     env: str  # the env it sets, by name
@@ -48,7 +66,7 @@ class _Setting:
     value: Any
 
 
-def with_variant(bundle: Bundle, variant: Variant) -> Bundle:
+def with_variant(bundle: Bundle, variant: Variant) -> Varied:
     """``bundle`` with ``variant``'s settings in its envs' tomls, and each entry that changes under an id ending in
     ``(<label>)``. Raises BundleError for a setting that isn't ``envs/NAME.KEY=VALUE`` or names no env of the bundle; the
     env's type checks the key and value as it checks an env.toml's."""
@@ -65,20 +83,11 @@ def with_variant(bundle: Bundle, variant: Variant) -> Bundle:
         new_id = renamed.get((entry.kind, entry.id))
         if new_id is None:
             entries.append(entry)
-        elif entry.kind is BundleKind.ENV:
-            entries.append(_renamed(entry, new_id, _repointed_toml(entry, configs.get(entry.id, entry.config), envs)))
-        elif entry.kind is BundleKind.TASK:
-            entries.append(_renamed(entry, new_id, _repointed_steps(entry.config, envs)))
-        else:
+        elif entry.kind is BundleKind.EVAL:
             entries.append(_renamed(entry, new_id, _eval(entry.config, tasks)))
-    return replace(bundle, entries=tuple(entries))
-
-
-def selected(before: Bundle, after: Bundle, names: Sequence[str], kind: BundleKind) -> tuple[str, ...]:
-    """``names``, a run's selections of ``kind`` by name or id, with the id of each entry ``after`` renames as its new
-    id."""
-    ids = {old.id: new.id for old, new in zip(before.entries, after.entries) if old.kind is kind and old.id != new.id}
-    return tuple(ids.get(name, name) for name in names)
+        else:
+            entries.append(_renamed(entry, new_id, _repointed(entry, configs.get(entry.id, entry.config), envs)))
+    return Varied(variant, replace(bundle, entries=tuple(entries)), renamed)
 
 
 def _parsed(texts: tuple[str, ...], names: set[str]) -> list[_Setting]:
@@ -125,7 +134,7 @@ def _set(config: dict, path: tuple[str, ...], value: Any) -> dict:
     return config
 
 
-def _renamed_ids(bundle: Bundle, changed: set[str], label: str) -> dict[str, str]:
+def _renamed_ids(bundle: Bundle, changed: set[str], label: str) -> dict[tuple[BundleKind, str], str]:
     """Each entry that changes, by kind and id, to its variant's id: the envs ``changed``, each env and task naming one
     that changes, by name or id, and each eval naming such a task. An id is unique within its kind alone."""
     by_name = {(entry.kind, entry.name): entry.id for entry in bundle.entries}
@@ -143,20 +152,21 @@ def _renamed_ids(bundle: Bundle, changed: set[str], label: str) -> dict[str, str
 
 
 def _names_env(entry: BundleEntry, envs: set[str], by_name: dict) -> bool:
-    return any(by_name.get((BundleKind.ENV, site.value), site.value) in envs for site in _env_sites(entry))
+    return any(by_name.get((BundleKind.ENV, site.value), site.value) in envs for site in _env_sites(entry, entry.config))
 
 
-def _env_sites(entry: BundleEntry):
+def _env_sites(entry: BundleEntry, config: Any) -> Iterator[RefSite]:
+    """Each env ``config``, ``entry``'s steps or toml, names by a name or id, as a site it can be rewritten at."""
     if entry.kind is BundleKind.TASK:
-        registry = get_task_step_registry()
-        for step in entry.config:
-            cls = registry.get(step.get("type")) if isinstance(step.get("type"), str) else None
-            yield from (site for site in ref_sites(cls.entity_refs or () if cls is not None else (), step)
-                        if site.ref.kind is EntityKind.ENV and isinstance(site.value, str))
+        sites = (site for step in config for site in ref_sites(_step_refs(step), step))
     else:
-        cls = get_env_registry().get(entry.type)
-        yield from (site for site in ref_sites(getattr(cls, "toml_refs", ()), entry.config, inline_pins=True)
-                    if site.ref.kind is EntityKind.ENV and isinstance(site.value, str))
+        sites = ref_sites(getattr(get_env_registry().get(entry.type), "toml_refs", ()), config, inline_pins=True)
+    return (site for site in sites if site.ref.kind is EntityKind.ENV and isinstance(site.value, str))
+
+
+def _step_refs(step: dict) -> tuple[EntityRef, ...]:
+    cls = get_task_step_registry().get(step["type"]) if isinstance(step.get("type"), str) else None
+    return (cls.entity_refs or ()) if cls is not None else ()
 
 
 def _renamed(entry: BundleEntry, new_id: str, config: Any) -> BundleEntry:
@@ -166,28 +176,15 @@ def _renamed(entry: BundleEntry, new_id: str, config: Any) -> BundleEntry:
     return replace(entry, id=new_id, config=config)
 
 
-def _repointed_toml(entry: BundleEntry, config: dict, renamed: dict[str, str]) -> dict:
-    """An env's toml with each env it names by an id that changes named by its variant's id."""
+def _repointed(entry: BundleEntry, config: Any, envs: dict[str, str]) -> Any:
+    """``config``, ``entry``'s steps or toml, with each env it names by an id that changes named by its variant's id."""
     config = copy.deepcopy(config)
-    cls = get_env_registry().get(entry.type)
-    for site in ref_sites(getattr(cls, "toml_refs", ()), config, inline_pins=True):
-        if site.ref.kind is EntityKind.ENV and site.value in renamed:
-            site.rewrite(renamed[site.value], site.version)
+    for site in _env_sites(entry, config):
+        if site.value in envs:
+            site.rewrite(envs[site.value], site.version)
     return config
 
 
-def _repointed_steps(steps: list[dict], renamed: dict[str, str]) -> list[dict]:
-    """A task's steps with each env a step names by an id that changes named by its variant's id."""
-    steps = copy.deepcopy(steps)
-    registry = get_task_step_registry()
-    for step in steps:
-        cls = registry.get(step.get("type")) if isinstance(step.get("type"), str) else None
-        for site in ref_sites(cls.entity_refs or () if cls is not None else (), step):
-            if site.ref.kind is EntityKind.ENV and site.value in renamed:
-                site.rewrite(renamed[site.value], site.version)
-    return steps
-
-
 def _eval(config: dict, renamed: dict[str, str]) -> dict:
     """An eval's toml with each task it names by an id that changes named by its variant's id."""
     return {**config, "tasks": [renamed.get(task, task) if isinstance(task, str) else task
diff --git a/tst/unit/bundle/_support.py b/tst/unit/bundle/_support.py
index 905abb5bd..88f8ec95a 100644
--- a/tst/unit/bundle/_support.py
+++ b/tst/unit/bundle/_support.py
@@ -5,7 +5,9 @@
 from importlib.metadata import PackageNotFoundError
 from pathlib import Path
 
+from agent_env.a2a_agent import A2AAgent
 from agent_env.artifact.artifacts.docker_image import DockerImageArtifact
+from agent_env.artifact.store import get_artifact_store
 from agent_env.bundle import parse_bundle
 from agent_env.bundle import requires as requires_module
 from agent_env.bundle.plan import plan_bundle
@@ -14,6 +16,7 @@
 from agent_env.env.published_images import AGENT_IMAGES
 from agent_env.plugins import Inventory, _requirements
 from agent_env.store.document_store import DocumentStore
+from agent_env.store.routing import namespace_routing
 
 # The image of the Claude Code agent agent-env ships.
 CLAUDE_CODE_IMAGE = next(image for image in AGENT_IMAGES if image.name == "agentenv-claude-code")
@@ -97,3 +100,11 @@ def ensure_index(self, collection, fields, unique=False, ttl_seconds=None):
         pass
 
     find_one = query = count = insert = update = update_one_and_get = replace = delete = None
+
+
+def store_agent(agent_id):
+    """An agent ``agent_id`` in the store, over an image that names a registry ref."""
+    with namespace_routing():
+        image = get_artifact_store().put_document(DockerImageArtifact(
+            id=f"{agent_id}-image", description="d", image_name="ghcr.io/acme/agent:1", tar_gz_s3_url="s3://b/x.tar.gz"))
+        return A2AAgent.put(id=agent_id, docker_image_artifact=image)
diff --git a/tst/unit/bundle/agent_override_test.py b/tst/unit/bundle/agent_override_test.py
index 301320be9..f4c670791 100644
--- a/tst/unit/bundle/agent_override_test.py
+++ b/tst/unit/bundle/agent_override_test.py
@@ -6,9 +6,6 @@
 import pytest
 from click.testing import CliRunner
 
-from agent_env.a2a_agent import A2AAgent
-from agent_env.artifact.artifacts.docker_image import DockerImageArtifact
-from agent_env.artifact.store import get_artifact_store
 from agent_env.bundle import BundleError, dry_run_bundle, parse_bundle, run_bundle
 from agent_env.bundle import preflight as preflight_module
 from agent_env.bundle.installed import InstalledBundle
@@ -17,11 +14,10 @@
 from agent_env.cli import cli
 from agent_env.entity.refs import EntityKind
 from agent_env.plugins._bundles import ALIASES_FILE
-from agent_env.store.routing import namespace_routing
 from agent_env.task.task import Task
 from agent_env.task_step.context import TaskStepContext
 from agent_env.task_step.task_steps.install_agent import InstallAgentTaskStep
-from tst.unit.bundle._support import layout
+from tst.unit.bundle._support import layout, store_agent
 
 ROOT = "@local/~/triage"
 SOLVER = "@local/demo-dist/kit/solver"
@@ -36,7 +32,7 @@
 @pytest.fixture
 def bundle_dir(tmp_path, monkeypatch, local_stores, cli_routing):
     monkeypatch.setenv("HOME", str(tmp_path))
-    _store_agent("theirs")
+    store_agent("theirs")
     return tmp_path / "triage"
 
 
@@ -48,13 +44,6 @@ def kit(tmp_path):
     return InstalledBundle("kit", "demo-dist", "1.0", "demo", root, None, None)
 
 
-def _store_agent(agent_id):
-    with namespace_routing():
-        image = get_artifact_store().put_document(DockerImageArtifact(
-            id=f"{agent_id}-image", description="d", image_name="ghcr.io/acme/agent:1", tar_gz_s3_url="s3://b/x.tar.gz"))
-        return A2AAgent.put(id=agent_id, docker_image_artifact=image)
-
-
 def _bundle(bundle_dir, steps, files=None):
     layout(bundle_dir, {"tasks/t.json": json.dumps(steps), **(files or {})})
     return bundle_dir
@@ -91,8 +80,8 @@ def test_this_bundles_own_agent_is_named_by_its_folder(bundle_dir):
 
 
 def test_the_stores_agent_is_named_by_its_id_at_the_version_the_plan_read(bundle_dir):
-    _store_agent("mine")
-    _store_agent("mine")
+    store_agent("mine")
+    store_agent("mine")
 
     plan = _plan(_bundle(bundle_dir, [DEPLOY, PROMPT]), "mine")
 
@@ -143,14 +132,14 @@ def record(self, where, provider, agent_id, version, *args, **kwargs):
             {"agents/helper/Dockerfile": "FROM scratch\n"})
 
     dry_run_bundle(bundle_dir, agent="helper")
-    _store_agent("mine")
+    store_agent("mine")
     dry_run_bundle(bundle_dir, agent="mine")
 
     assert checked == [(f"{ROOT}/helper", None), ("mine", 1)]
 
 
 def test_an_install_is_checked_for_the_agent_the_solver_installs_not_the_one_the_task_names(bundle_dir):
-    _store_agent("mine")
+    store_agent("mine")
     _bundle(bundle_dir, INSTALL, {"agents/helper/Dockerfile": "FROM scratch\n"})
 
     with pytest.raises(BundleError, match="install_agent 'agent': Agent theirs v1 has no build_context_object_url"):
@@ -162,7 +151,7 @@ def test_an_install_is_checked_for_the_agent_the_solver_installs_not_the_one_the
 
 def test_a_dry_run_says_what_the_solver_deploys(bundle_dir, monkeypatch):
     lines = []
-    _store_agent("mine")
+    store_agent("mine")
 
     dry_run_bundle(_bundle(bundle_dir, [{**DEPLOY, "sandbox_type": "local"}, PROMPT]), agent="mine",
                    on_progress=lines.append)
@@ -191,12 +180,12 @@ def test_a_run_deploys_the_stores_agent_at_the_version_the_plan_read_not_one_put
     seen = {}
 
     async def run(self, *, context, **kwargs):
-        _store_agent("mine")
+        store_agent("mine")
         seen[self.id] = context.metadata.get("user_overrides")
         return context
 
     monkeypatch.setattr(Task, "run", run)
-    _store_agent("mine")
+    store_agent("mine")
     _bundle(bundle_dir, [DEPLOY, PROMPT])
 
     run_bundle(bundle_dir, agent="mine", sandbox="local")
@@ -216,7 +205,7 @@ def test_an_install_takes_its_steps_override_over_the_run_wide_one_and_the_store
 
 def test_the_cli_takes_the_agent_for_a_run_and_a_dry_run(bundle_dir, monkeypatch):
     monkeypatch.setenv("LITELLM_BASE_URL", "http://litellm")
-    _store_agent("mine")
+    store_agent("mine")
     _bundle(bundle_dir, [{**DEPLOY, "sandbox_type": "local"}, PROMPT])
 
     result = CliRunner().invoke(cli, ["run", str(bundle_dir), "--agent", "mine", "--dry-run"])
diff --git a/tst/unit/bundle/computer_env_folder_test.py b/tst/unit/bundle/computer_env_folder_test.py
index af0dcec40..3259c32d4 100644
--- a/tst/unit/bundle/computer_env_folder_test.py
+++ b/tst/unit/bundle/computer_env_folder_test.py
@@ -14,7 +14,6 @@
 from agent_env.bundle.resolve import resolve_bundle
 from agent_env.bundle.run import dry_run_bundle
 from agent_env.env import Env
-from agent_env.env.envs.computer.utils import composer
 from agent_env.env.envs.computer.utils.composed import composition
 from agent_env.env.envs.computer.utils.composer import Composing
 from agent_env.env.envs.computer.env import ComputerEnv
@@ -41,22 +40,6 @@
     ("skill-linux.md", "# Mail on Linux\n"))}
 
 
-@pytest.fixture
-def composed(tmp_path, monkeypatch, local_stores, cli_routing, builds):
-    monkeypatch.setenv("HOME", str(tmp_path))
-    monkeypatch.setattr("agent_env.env.published_images._registry_digest", lambda ref: None)
-    calls = []
-
-    def compose(env, pairs=None, composing=Composing()):
-        if composing.on_progress is not None:
-            composing.on_progress("composing")
-        calls.append((env.id, env.computer.id, env.driver.id, composing.sandbox_provider)
-                     + ((pairs,) if pairs is not None else ()))
-
-    monkeypatch.setattr(composer, "compose", compose)
-    return calls
-
-
 def _bundle(root, toml=DESKTOP, extra=None):
     return layout(root, {"envs/desktop/env.toml": toml, "tasks/t.json": json.dumps([
         {"id": "desktop", "type": "load_artifact", "env_id": "desktop", "artifact_id": "notes"}]),
diff --git a/tst/unit/bundle/conftest.py b/tst/unit/bundle/conftest.py
index 1725af771..de395bf32 100644
--- a/tst/unit/bundle/conftest.py
+++ b/tst/unit/bundle/conftest.py
@@ -6,6 +6,8 @@
 import pytest
 
 from agent_env.artifact.artifacts import docker_image as docker_image_module
+from agent_env.env.envs.computer.utils import composer
+from agent_env.env.envs.computer.utils.composer import Composing
 from agent_env.env.published_images import AGENT_IMAGES
 from agent_env.providers.sandbox_providers import host_images
 from tst.unit.bundle._support import CLAUDE_CODE_IMAGE, DIGEST, listing
@@ -51,3 +53,21 @@ def agents_published(monkeypatch):
     refs = {image.ref() for image in AGENT_IMAGES}
     monkeypatch.setattr("agent_env.env.published_images._registry_digest", lambda ref: DIGEST if ref in refs else None)
     return CLAUDE_CODE_IMAGE.ref()
+
+
+@pytest.fixture
+def composed(tmp_path, monkeypatch, local_stores, cli_routing, builds):
+    """Stands in for the composer: each computer env it's asked to compose is recorded with its computer, driver, provider
+    and, when given, the pairs, and nothing is built."""
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setattr("agent_env.env.published_images._registry_digest", lambda ref: None)
+    calls = []
+
+    def compose(env, pairs=None, composing=Composing()):
+        if composing.on_progress is not None:
+            composing.on_progress("composing")
+        calls.append((env.id, env.computer.id, env.driver.id, composing.sandbox_provider)
+                     + ((pairs,) if pairs is not None else ()))
+
+    monkeypatch.setattr(composer, "compose", compose)
+    return calls
diff --git a/tst/unit/bundle/installed_entities_test.py b/tst/unit/bundle/installed_entities_test.py
index 2e20e810f..88d8e6dcf 100644
--- a/tst/unit/bundle/installed_entities_test.py
+++ b/tst/unit/bundle/installed_entities_test.py
@@ -25,7 +25,7 @@
 from agent_env.entity.refs import EntityKind
 from agent_env.env.envs.mcp_server import MCPServerEnv
 from agent_env.store.routing import namespace_routing
-from tst.unit.bundle._support import RefusingStore, layout, local_builds
+from tst.unit.bundle._support import RefusingStore, layout, local_builds, store_agent
 
 ROOT = "@local/~/triage"
 KIT = "@local/demo-dist/kit"
@@ -383,13 +383,6 @@ def test_a_run_locks_the_entities_it_pulls_in_as_it_does_its_own(bundle_dir, tmp
 ALIASED = {ALIASES_FILE: '[agents]\nsolver = ["solver-x"]\n'}
 
 
-def _store_agent(agent_id):
-    with namespace_routing():
-        image = get_artifact_store().put_document(DockerImageArtifact(
-            id=f"{agent_id}-image", description="d", image_name="ghcr.io/acme/agent:1", tar_gz_s3_url="s3://b/x.tar.gz"))
-        return A2AAgent.put(id=agent_id, docker_image_artifact=image)
-
-
 def _step(plan, step_id="agent"):
     task = next(write for write in plan.writes if write.kind is BundleKind.TASK)
     return next(step for step in task.source.config if step["id"] == step_id)
@@ -498,7 +491,7 @@ def test_an_installed_bundles_env_naming_another_bundles_alias_is_pointed_at_it_
 def test_the_stores_agent_of_an_alias_id_shadows_the_alias(bundle_dir, tmp_path):
     """Someone's own agent of that id is the one they mean."""
     kit = _kit(tmp_path, ALIASED)
-    _store_agent("solver-x")
+    store_agent("solver-x")
 
     plan = _plan(_task(bundle_dir, [{"id": "agent", "type": "deploy_agent", "a2a_agent_id": "solver-x"}]), kit)
 
@@ -541,7 +534,7 @@ def test_an_alias_takes_no_pin(bundle_dir, tmp_path):
 
 def test_a_pinned_reference_to_the_stores_agent_of_an_alias_id_names_that_agent(bundle_dir, tmp_path):
     kit = _kit(tmp_path, ALIASED)
-    _store_agent("solver-x")
+    store_agent("solver-x")
 
     plan = _plan(_task(bundle_dir, [{"id": "agent", "type": "deploy_agent", "a2a_agent_id": "solver-x",
                                      "a2a_agent_version": 1}]), kit)
@@ -568,7 +561,7 @@ def test_the_stores_agent_of_a_refused_alias_id_is_the_one_it_names(bundle_dir,
     other = _installed(tmp_path / "site2" / "tools", {"agents/helper/Dockerfile": "FROM scratch\n",
                                                       ALIASES_FILE: '[agents]\nhelper = ["solver-x"]\n'},
                        dist="zeta-tools", name="tools")
-    _store_agent("solver-x")
+    store_agent("solver-x")
 
     plan = _plan(_task(bundle_dir, [{"id": "agent", "type": "deploy_agent", "a2a_agent_id": "solver-x"}]), kit, other)
 
@@ -639,7 +632,7 @@ def test_a_dry_run_says_which_agent_an_alias_names_and_preflights_an_aliased_def
 
 def test_a_dry_run_says_when_the_store_shadows_an_alias(bundle_dir, tmp_path, monkeypatch):
     kit = _kit(tmp_path, ALIASED)
-    _store_agent("solver-x")
+    store_agent("solver-x")
     monkeypatch.setattr(run_module, "installed_bundles", lambda: (kit,))
     monkeypatch.setattr(preflight_module, "docker_unreachable", lambda: None)
     _task(bundle_dir, [{"id": "agent", "type": "deploy_agent", "a2a_agent_id": "solver-x"}])
diff --git a/tst/unit/bundle/variants_test.py b/tst/unit/bundle/variants_test.py
index d660372e8..4e5d63317 100644
--- a/tst/unit/bundle/variants_test.py
+++ b/tst/unit/bundle/variants_test.py
@@ -6,7 +6,7 @@
 import pytest
 from click.testing import CliRunner
 
-from agent_env.bundle import BundleError, Variant, dry_run_bundle, parse_bundle
+from agent_env.bundle import BundleError, BundleKind, Variant, dry_run_bundle, parse_bundle
 from agent_env.bundle.installed import installed_bundles
 from agent_env.bundle.materialize import materialize
 from agent_env.bundle.plan import plan_bundle
@@ -14,9 +14,8 @@
 from agent_env.bundle.variants import with_variant
 from agent_env.cli import cli
 from agent_env.env import Env
-from tst.unit.bundle._support import layout, local_builds
-from tst.unit.bundle.agent_override_test import _store_agent
-from tst.unit.bundle.computer_env_folder_test import APPS, DESKTOP, UBUNTU, WITH_APPS, composed  # noqa: F401
+from tst.unit.bundle._support import layout, local_builds, store_agent
+from tst.unit.bundle.computer_env_folder_test import APPS, DESKTOP, UBUNTU, WITH_APPS
 
 ROOT = "@local/~/desk"
 CUA = "@local/agentenv-framework/drivers/cua-driver"
@@ -38,7 +37,7 @@ def _bundle(root, steps=(DEPLOY, AGENT, PROMPT), files=None):
 
 
 def _varied(root, *settings):
-    return with_variant(parse_bundle(root), Variant(settings))
+    return with_variant(parse_bundle(root), Variant(settings)).bundle
 
 
 def _entry(bundle, name):
@@ -52,9 +51,12 @@ def _ids(bundle):
 def test_a_key_set_renames_the_env_and_what_uses_it_and_leaves_the_rest(tmp_path):
     root = _bundle(tmp_path / "desk")
 
-    bundle = _varied(root, "envs/desktop.driver=cua-driver")
+    varied = with_variant(parse_bundle(root), Variant(("envs/desktop.driver=cua-driver",)))
 
-    label = "desktop.driver cua-driver"
+    label, bundle = "desktop.driver cua-driver", varied.bundle
+    assert dict(varied.renamed) == {(BundleKind.ENV, f"{ROOT}/desktop"): f"{ROOT}/desktop({label})",
+                                    (BundleKind.TASK, f"{ROOT}/t"): f"{ROOT}/t({label})",
+                                    (BundleKind.EVAL, f"{ROOT}/e"): f"{ROOT}/e({label})"}
     assert _ids(bundle) == {"desktop": f"{ROOT}/desktop({label})", "t": f"{ROOT}/t({label})", "chat": f"{ROOT}/chat",
                             "e": f"{ROOT}/e({label})", "chats": f"{ROOT}/chats"}
     assert _entry(bundle, "desktop").config == {**_entry(parse_bundle(root), "desktop").config, "driver": "cua-driver"}
@@ -131,7 +133,7 @@ def test_a_setting_that_names_no_envs_key_is_refused(tmp_path, setting, problem)
 
 @pytest.fixture
 def desk(tmp_path, local_stores, cli_routing):
-    _store_agent("theirs")
+    store_agent("theirs")
     return _bundle(tmp_path / "desk")
 
 
@@ -139,7 +141,7 @@ def _plan(root, *settings):
     return plan_bundle(resolve_bundle(_varied(root, *settings)), installed=installed_bundles)
 
 
-def test_the_variant_is_written_and_composed_with_its_driver_beside_the_bundles_own(desk, composed):  # noqa: F811
+def test_the_variant_is_written_and_composed_with_its_driver_beside_the_bundles_own(desk, composed):
     plan = _plan(desk, "envs/desktop.driver=cua-driver", "envs/desktop.tools=driver")
 
     materialize(plan, build_here=local_builds(plan))
@@ -155,7 +157,7 @@ def test_the_variant_is_written_and_composed_with_its_driver_beside_the_bundles_
     ("envs/desktop.drivr=x", "unknown key 'drivr'; a computer env takes environment_name, computer, driver, apps, "
                              "display, network, computer_settings, tools, type and id"),
 ])
-def test_a_key_or_value_the_envs_type_refuses_is_refused_before_anything_is_written(desk, composed,  # noqa: F811
+def test_a_key_or_value_the_envs_type_refuses_is_refused_before_anything_is_written(desk, composed,
                                                                                      setting, problem):
     with pytest.raises(BundleError) as refused:
         dry_run_bundle(desk, variant=Variant((setting,)))
@@ -163,7 +165,7 @@ def test_a_key_or_value_the_envs_type_refuses_is_refused_before_anything_is_writ
     assert any(line.startswith("envs/desktop") and problem in line for line in refused.value.problems), refused.value
 
 
-def test_a_driver_that_cant_compose_with_the_computer_is_refused_as_its_written(desk, composed):  # noqa: F811
+def test_a_driver_that_cant_compose_with_the_computer_is_refused_as_its_written(desk, composed):
     plan = _plan(desk, "envs/desktop.driver=macos-harness")
 
     with pytest.raises(BundleError) as refused:
@@ -174,7 +176,7 @@ def test_a_driver_that_cant_compose_with_the_computer_is_refused_as_its_written(
     assert composed == []
 
 
-def test_a_run_whose_tasks_deploy_nothing_its_settings_change_is_refused(desk, composed):  # noqa: F811
+def test_a_run_whose_tasks_deploy_nothing_its_settings_change_is_refused(desk, composed):
     with pytest.raises(BundleError) as refused:
         dry_run_bundle(desk, tasks=["chat"], variant=Variant(("envs/desktop.driver=cua-driver",)))
 
@@ -183,13 +185,13 @@ def test_a_run_whose_tasks_deploy_nothing_its_settings_change_is_refused(desk, c
 
 
 @pytest.mark.parametrize("selection", ["t", f"{ROOT}/t"], ids=["name", "id"])
-def test_a_task_is_selected_by_its_name_or_its_id_as_the_bundle_gives_it(desk, composed, selection):  # noqa: F811
+def test_a_task_is_selected_by_its_name_or_its_id_as_the_bundle_gives_it(desk, composed, selection):
     dry = dry_run_bundle(desk, tasks=[selection], variant=Variant(("envs/desktop.driver=cua-driver",)))
 
     assert [entry.id for entry in dry.runs] == [f"{ROOT}/t(desktop.driver cua-driver)"]
 
 
-def test_the_cli_runs_the_variant_and_says_what_it_writes_it_as(desk, composed, monkeypatch):  # noqa: F811
+def test_the_cli_runs_the_variant_and_says_what_it_writes_it_as(desk, composed, monkeypatch):
     monkeypatch.setenv("LITELLM_BASE_URL", "http://litellm")
 
     result = CliRunner().invoke(cli, ["run", str(desk), "--task", "t", "--set", "envs/desktop.driver=cua-driver",

From 1e0868b7a5a3ffec81d425879ebc46fb29b77329 Mon Sep 17 00:00:00 2001
From: Edgar Arakelyan <edgar.arakelyan@scale.com>
Date: Thu, 5 Nov 2026 16:09:03 -0800
Subject: [PATCH 4/6] fix(run): --set follows an eval's tasks as the resolver
 reads them, and refuses type and id

An entry's references are walked through its class's refs as the resolver
walks them, so an eval naming its task in a table, by name or id, is renamed
and repointed like one naming it as a string. A run can't set an env's type
or id: they say what the entry is, and the planner reads the type from the
entry, not its toml.

Refs FD-4362

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/agent_env/bundle/variants.py | 54 +++++++++++++++++---------------
 tst/unit/bundle/variants_test.py | 14 +++++++++
 2 files changed, 42 insertions(+), 26 deletions(-)

diff --git a/src/agent_env/bundle/variants.py b/src/agent_env/bundle/variants.py
index 59701ed81..c1c6b0a75 100644
--- a/src/agent_env/bundle/variants.py
+++ b/src/agent_env/bundle/variants.py
@@ -12,13 +12,15 @@
 from typing import Any
 
 from agent_env.entity.refs import EntityKind, EntityRef, RefSite, ref_sites
-from agent_env.env.registry import get_env_registry
 from agent_env.task_step.registry import get_task_step_registry
 
 from .parse import Bundle, BundleEntry, BundleError, BundleKind, segment_problem
+from .resolve import entity_class
 
 _TARGET = f"{BundleKind.ENV.value}/"
 _FORM = "envs/NAME.KEY=VALUE, such as envs/desktop.driver=cua-driver"
+#: The keys that say what an entry is rather than how it's set, which a run can't change.
+_FIXED = ("type", "id")
 
 
 @dataclass(frozen=True)
@@ -78,15 +80,14 @@ def with_variant(bundle: Bundle, variant: Variant) -> Varied:
     renamed = _renamed_ids(bundle, set(configs), variant.label)
     envs, tasks = ({entry_id: new for (kind, entry_id), new in renamed.items() if kind is of}
                    for of in (BundleKind.ENV, BundleKind.TASK))
+    renaming = {EntityKind.ENV: envs, EntityKind.TASK: tasks}
     entries = []
     for entry in bundle.entries:
         new_id = renamed.get((entry.kind, entry.id))
         if new_id is None:
             entries.append(entry)
-        elif entry.kind is BundleKind.EVAL:
-            entries.append(_renamed(entry, new_id, _eval(entry.config, tasks)))
         else:
-            entries.append(_renamed(entry, new_id, _repointed(entry, configs.get(entry.id, entry.config), envs)))
+            entries.append(_renamed(entry, new_id, _repointed(entry, configs.get(entry.id, entry.config), renaming)))
     return Varied(variant, replace(bundle, entries=tuple(entries)), renamed)
 
 
@@ -105,6 +106,9 @@ def _parsed(texts: tuple[str, ...], names: set[str]) -> list[_Setting]:
         if not all(path):
             problems.append(f"--set {text}: expected {_FORM}")
             continue
+        if path[0] in _FIXED:
+            problems.append(f"--set {text}: an env's {path[0]} says what it is, so a run can't set it")
+            continue
         settings.append(_Setting(env, path, _value(raw)))
     if problems:
         raise BundleError(problems)
@@ -140,28 +144,31 @@ def _renamed_ids(bundle: Bundle, changed: set[str], label: str) -> dict[tuple[Bu
     by_name = {(entry.kind, entry.name): entry.id for entry in bundle.entries}
     envs = set(changed)
     while more := {entry.id for entry in bundle.entries if entry.kind is BundleKind.ENV and entry.id not in envs
-                   and _names_env(entry, envs, by_name)}:
+                   and _names(entry, EntityKind.ENV, envs, by_name)}:
         envs |= more
-    tasks = {entry.id for entry in bundle.entries if entry.kind is BundleKind.TASK and _names_env(entry, envs, by_name)}
-    evals = {entry.id for entry in bundle.entries if entry.kind is BundleKind.EVAL and any(
-        by_name.get((BundleKind.TASK, task), task) in tasks for task in entry.config.get("tasks") or []
-        if isinstance(task, str))}
+    tasks = {entry.id for entry in bundle.entries if entry.kind is BundleKind.TASK
+             and _names(entry, EntityKind.ENV, envs, by_name)}
+    evals = {entry.id for entry in bundle.entries if entry.kind is BundleKind.EVAL
+             and _names(entry, EntityKind.TASK, tasks, by_name)}
     return {(kind, entry_id): f"{entry_id}({label})"
             for kind, ids in ((BundleKind.ENV, envs), (BundleKind.TASK, tasks), (BundleKind.EVAL, evals))
             for entry_id in ids}
 
 
-def _names_env(entry: BundleEntry, envs: set[str], by_name: dict) -> bool:
-    return any(by_name.get((BundleKind.ENV, site.value), site.value) in envs for site in _env_sites(entry, entry.config))
+def _names(entry: BundleEntry, kind: EntityKind, ids: set[str], by_name: dict) -> bool:
+    """Whether ``entry`` names one of ``ids``, entries of ``kind``, by its name or id."""
+    of = {EntityKind.ENV: BundleKind.ENV, EntityKind.TASK: BundleKind.TASK}[kind]
+    return any(by_name.get((of, site.value), site.value) in ids for site in _sites(entry, entry.config) if site.ref.kind is kind)
 
 
-def _env_sites(entry: BundleEntry, config: Any) -> Iterator[RefSite]:
-    """Each env ``config``, ``entry``'s steps or toml, names by a name or id, as a site it can be rewritten at."""
+def _sites(entry: BundleEntry, config: Any) -> Iterator[RefSite]:
+    """Each entity ``config``, ``entry``'s steps or toml, names by a name or id, as a site it can be rewritten at, as the
+    resolver reads them."""
     if entry.kind is BundleKind.TASK:
         sites = (site for step in config for site in ref_sites(_step_refs(step), step))
     else:
-        sites = ref_sites(getattr(get_env_registry().get(entry.type), "toml_refs", ()), config, inline_pins=True)
-    return (site for site in sites if site.ref.kind is EntityKind.ENV and isinstance(site.value, str))
+        sites = ref_sites(getattr(entity_class(entry), "toml_refs", ()), config, inline_pins=True)
+    return (site for site in sites if isinstance(site.value, str))
 
 
 def _step_refs(step: dict) -> tuple[EntityRef, ...]:
@@ -176,16 +183,11 @@ def _renamed(entry: BundleEntry, new_id: str, config: Any) -> BundleEntry:
     return replace(entry, id=new_id, config=config)
 
 
-def _repointed(entry: BundleEntry, config: Any, envs: dict[str, str]) -> Any:
-    """``config``, ``entry``'s steps or toml, with each env it names by an id that changes named by its variant's id."""
+def _repointed(entry: BundleEntry, config: Any, renaming: dict[EntityKind, dict[str, str]]) -> Any:
+    """``config``, ``entry``'s steps or toml, with each env or task it names by an id that changes named by its variant's
+    id."""
     config = copy.deepcopy(config)
-    for site in _env_sites(entry, config):
-        if site.value in envs:
-            site.rewrite(envs[site.value], site.version)
+    for site in _sites(entry, config):
+        if site.value in renaming.get(site.ref.kind, {}):
+            site.rewrite(renaming[site.ref.kind][site.value], site.version)
     return config
-
-
-def _eval(config: dict, renamed: dict[str, str]) -> dict:
-    """An eval's toml with each task it names by an id that changes named by its variant's id."""
-    return {**config, "tasks": [renamed.get(task, task) if isinstance(task, str) else task
-                                for task in config.get("tasks") or []]}
diff --git a/tst/unit/bundle/variants_test.py b/tst/unit/bundle/variants_test.py
index 4e5d63317..f60af531b 100644
--- a/tst/unit/bundle/variants_test.py
+++ b/tst/unit/bundle/variants_test.py
@@ -86,6 +86,17 @@ def test_a_reference_by_id_is_repointed_at_the_variant(tmp_path):
     assert _entry(bundle, "desktop").config["tools"] == "standard"
 
 
+@pytest.mark.parametrize("named", ["t", f"{ROOT}/t"], ids=["name", "id"])
+def test_an_eval_naming_its_task_in_a_table_is_renamed_and_repointed_too(tmp_path, named):
+    root = _bundle(tmp_path / "desk", files={"evals/e.toml": f'tasks = [{{ task = "{named}" }}]\n'})
+
+    bundle = _varied(root, "envs/desktop.driver=cua-driver")
+
+    label = "desktop.driver cua-driver"
+    assert _entry(bundle, "e").id == f"{ROOT}/e({label})"
+    assert _entry(bundle, "e").config["tasks"] == [{"task": "t" if named == "t" else f"{ROOT}/t({label})"}]
+
+
 def test_a_value_is_toml_or_a_bare_word_and_a_key_may_be_dotted_into_a_table(tmp_path):
     settings = ("envs/desktop.display={ width = 1280, height = 720 }", "envs/desktop.computer_settings.theme=dark",
                 "envs/desktop.network.mode=allow_all")
@@ -123,6 +134,9 @@ def test_one_env_is_set_by_its_folder_and_an_env_composing_an_app_set_is_renamed
     ("envs/desktop=x", "--set envs/desktop=x: expected envs/NAME.KEY=VALUE, such as envs/desktop.driver=cua-driver"),
     ("envs/desktop.=x", "--set envs/desktop.=x: expected envs/NAME.KEY=VALUE, such as envs/desktop.driver=cua-driver"),
     ("envs/nope.driver=x", "--set envs/nope.driver=x: envs/nope names no env of this bundle"),
+    ("envs/desktop.type=website", "--set envs/desktop.type=website: an env's type says what it is, so a run can't set "
+                                  "it"),
+    ("envs/desktop.id=x", "--set envs/desktop.id=x: an env's id says what it is, so a run can't set it"),
 ])
 def test_a_setting_that_names_no_envs_key_is_refused(tmp_path, setting, problem):
     with pytest.raises(BundleError) as refused:

From 866076e803f92ce2b282c42bf1407b9e4dcbf8cc Mon Sep 17 00:00:00 2001
From: Edgar Arakelyan <edgar.arakelyan@scale.com>
Date: Thu, 5 Nov 2026 16:16:19 -0800
Subject: [PATCH 5/6] fix(run): --set keeps an eval sharing an env's id on its
 own toml

The tomls --set changes are keyed by kind and id, since an id is unique within
its kind alone: an eval with the env's default id, renamed because it names a
task the env's change reaches, keeps its own tasks.

Refs FD-4362

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/agent_env/bundle/variants.py | 11 ++++++-----
 tst/unit/bundle/variants_test.py | 10 ++++++++++
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/src/agent_env/bundle/variants.py b/src/agent_env/bundle/variants.py
index c1c6b0a75..ce13272d8 100644
--- a/src/agent_env/bundle/variants.py
+++ b/src/agent_env/bundle/variants.py
@@ -73,11 +73,11 @@ def with_variant(bundle: Bundle, variant: Variant) -> Varied:
     ``(<label>)``. Raises BundleError for a setting that isn't ``envs/NAME.KEY=VALUE`` or names no env of the bundle; the
     env's type checks the key and value as it checks an env.toml's."""
     by_name = {entry.name: entry for entry in bundle.entries if entry.kind is BundleKind.ENV}
-    configs = {}
+    configs = {}  # each env's toml with its settings, by kind and id, as an id is unique within its kind alone
     for setting in _parsed(variant.settings, set(by_name)):
-        entry = by_name[setting.env]
-        configs[entry.id] = _set(configs.get(entry.id, entry.config), setting.path, setting.value)
-    renamed = _renamed_ids(bundle, set(configs), variant.label)
+        key = (BundleKind.ENV, by_name[setting.env].id)
+        configs[key] = _set(configs.get(key, by_name[setting.env].config), setting.path, setting.value)
+    renamed = _renamed_ids(bundle, {entry_id for _, entry_id in configs}, variant.label)
     envs, tasks = ({entry_id: new for (kind, entry_id), new in renamed.items() if kind is of}
                    for of in (BundleKind.ENV, BundleKind.TASK))
     renaming = {EntityKind.ENV: envs, EntityKind.TASK: tasks}
@@ -87,7 +87,8 @@ def with_variant(bundle: Bundle, variant: Variant) -> Varied:
         if new_id is None:
             entries.append(entry)
         else:
-            entries.append(_renamed(entry, new_id, _repointed(entry, configs.get(entry.id, entry.config), renaming)))
+            config = configs.get((entry.kind, entry.id), entry.config)
+            entries.append(_renamed(entry, new_id, _repointed(entry, config, renaming)))
     return Varied(variant, replace(bundle, entries=tuple(entries)), renamed)
 
 
diff --git a/tst/unit/bundle/variants_test.py b/tst/unit/bundle/variants_test.py
index f60af531b..88a62bdff 100644
--- a/tst/unit/bundle/variants_test.py
+++ b/tst/unit/bundle/variants_test.py
@@ -73,6 +73,16 @@ def test_an_entry_of_another_kind_with_the_envs_id_stays_as_it_is(tmp_path):
     assert _entry(bundle, "t").id == f"{ROOT}/t(desktop.driver cua-driver)"
 
 
+def test_an_eval_sharing_the_envs_id_keeps_its_own_toml(tmp_path):
+    root = _bundle(tmp_path / "desk", files={"evals/desktop.toml": 'tasks = ["t"]\n'})
+
+    bundle = _varied(root, "envs/desktop.driver=cua-driver")
+
+    evals = {entry.id: entry.config for entry in bundle.entries if entry.kind is BundleKind.EVAL}
+    assert evals[f"{ROOT}/desktop(desktop.driver cua-driver)"] == {"tasks": ["t"]}
+    assert _entry(bundle, "desktop").config["driver"] == "cua-driver"
+
+
 def test_a_reference_by_id_is_repointed_at_the_variant(tmp_path):
     steps = [{**DEPLOY, "env_id": f"{ROOT}/desktop"}, {**AGENT, "env_ids": [f"{ROOT}/desktop"]}, PROMPT]
     root = _bundle(tmp_path / "desk", steps, {"evals/e.toml": f'tasks = ["{ROOT}/t"]\n'})

From b9cb9f7855b33bf7b716db91132a74240f3b5aaf Mon Sep 17 00:00:00 2001
From: Edgar Arakelyan <edgar.arakelyan@scale.com>
Date: Thu, 5 Nov 2026 17:41:29 -0800
Subject: [PATCH 6/6] test(run): --set and a computer env's tools on real
 computers, local and on a Modal VM

tst/integration/computer/set_test.py runs the set test bundle's cua-driver desktop through agent-env run, listing what
the agents' role is offered before and after a reset: each tools value (unset, standard, driver) on local Docker, a
driver set for the run composed and deployed under the variant's id with the bundle's own env unwritten, and
tools=standard on a Modal VM through a reset in place. run_context reads an instance id with spaces, as a variant's has.

The Modal test found a disk export that failed on an arm64 machine whenever the amd64 disk's image wasn't in its
Docker: docker create resolved this machine's platform, which the image's index doesn't hold. The export now creates
for the disk's own platform, the one the Modal VM provider boots.

Refs FD-4362

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../sandbox_providers/local_docker/disk.py    | 12 +--
 .../sandbox_providers/modal_vm_sandbox.py     |  3 +-
 tst/integration/computer/conftest.py          |  2 +-
 .../set/artifacts/check_tools/verify.py       | 14 ++++
 .../computer/set/envs/desktop/env.toml        |  3 +
 tst/integration/computer/set/tasks/tools.json |  6 ++
 tst/integration/computer/set_test.py          | 84 +++++++++++++++++++
 tst/unit/env/envs/test_disk_recipe.py         |  4 +-
 .../modal_create_signature_test.py            |  2 +-
 .../modal_vm_sandbox_test.py                  |  5 +-
 10 files changed, 122 insertions(+), 13 deletions(-)
 create mode 100644 tst/integration/computer/set/artifacts/check_tools/verify.py
 create mode 100644 tst/integration/computer/set/envs/desktop/env.toml
 create mode 100644 tst/integration/computer/set/tasks/tools.json
 create mode 100644 tst/integration/computer/set_test.py

diff --git a/src/agent_env/providers/sandbox_providers/local_docker/disk.py b/src/agent_env/providers/sandbox_providers/local_docker/disk.py
index 34bc948db..4f387f691 100644
--- a/src/agent_env/providers/sandbox_providers/local_docker/disk.py
+++ b/src/agent_env/providers/sandbox_providers/local_docker/disk.py
@@ -45,23 +45,23 @@ def launcher_args(ports: list[int], env: dict[str, str], cpu: float, memory: int
                                for arg in ("-e", f"{name}={value}"))]
 
 
-def exported_disk(image: str) -> Path:
+def exported_disk(image: str, platform: str) -> Path:
     """``image``'s ``DISK_FILE`` compressed with zstd in this machine's cache, exported from its image store by this
     machine's Docker unless an export of it is there already: once for each composed disk, by its ref, whose tag is its
-    composer's key."""
+    composer's key. ``platform`` is the disk's own, which this machine's Docker may not be."""
     path = cache_root() / "disks" / f"{hashlib.sha256(image.encode()).hexdigest()[:32]}.img.zst"
     with holding_locks([f"disk-export:{path.name}"]):
         if not path.exists():
-            _export(image, path)
+            _export(image, platform, path)
     return path
 
 
-def _export(image: str, path: Path) -> None:
+def _export(image: str, platform: str, path: Path) -> None:
     """Signed in to the image store first, as a boot's pull is, since ``docker create`` pulls ``image`` when it isn't
-    here."""
+    here; for ``platform``, as the image's index holds that one alone, which a pull for this machine's wouldn't find."""
     path.parent.mkdir(parents=True, exist_ok=True)
     docker_login(get_config().get_image_store().auth(image))
-    container = docker("create", image, "disk")
+    container = docker("create", "--platform", platform, image, "disk")
     try:
         with tempfile.TemporaryDirectory(prefix="export-", dir=path.parent) as work:
             raw, compressed = Path(work) / "disk.img", Path(work) / path.name
diff --git a/src/agent_env/providers/sandbox_providers/modal_vm_sandbox.py b/src/agent_env/providers/sandbox_providers/modal_vm_sandbox.py
index 58d1ecb92..10057a1b0 100644
--- a/src/agent_env/providers/sandbox_providers/modal_vm_sandbox.py
+++ b/src/agent_env/providers/sandbox_providers/modal_vm_sandbox.py
@@ -364,7 +364,8 @@ async def create_vm(
                                        attribution=attribution, network_policy=network_policy,
                                        setup_for_gateway=setup_for_gateway, idle_timeout=self._idle_timeout,
                                        experimental_options={"vm_runtime": True})
-        disk = await asyncio.to_thread(exported_disk, image)
+        (platform,) = self.disk_image_platforms()
+        disk = await asyncio.to_thread(exported_disk, image, platform)
         variables = {**launcher_variables(ports, env or {}, cpu, memory), "VM_DISK": _MOUNTED_DISK}
         return await self._created(
             (LAUNCH,), (await _launcher()).add_local_file(disk, _MOUNTED_DISK, copy=False), cpu=cpu,
diff --git a/tst/integration/computer/conftest.py b/tst/integration/computer/conftest.py
index 9ee81468f..ac448aa70 100644
--- a/tst/integration/computer/conftest.py
+++ b/tst/integration/computer/conftest.py
@@ -143,4 +143,4 @@ def state(monkeypatch, tmp_path):
 def run_context(output: str) -> dict:
     """The context of the run whose ``agent-env run`` output ``output`` is."""
     with namespace_routing():
-        return get_task_instance_store().get(re.search(r"instance (@local/\S+)", output).group(1)).context
+        return get_task_instance_store().get(re.search(r"instance (@local/.+)$", output, re.M).group(1)).context
diff --git a/tst/integration/computer/set/artifacts/check_tools/verify.py b/tst/integration/computer/set/artifacts/check_tools/verify.py
new file mode 100644
index 000000000..d4ef4bc58
--- /dev/null
+++ b/tst/integration/computer/set/artifacts/check_tools/verify.py
@@ -0,0 +1,14 @@
+"""What the agents' role sees on the computer: AgentEnv's computer_* tools and the driver's own, each result naming them."""
+from mcp import ClientSession
+from mcp.client.streamable_http import streamable_http_client
+
+
+async def verify(mcp_url):
+    async with streamable_http_client(mcp_url) as (read, write, _):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+            names = sorted(tool.name for tool in (await session.list_tools()).tools)
+    computer = [name for name in names if name.startswith("computer_")]
+    own = [name for name in names if not name.startswith("computer_")]
+    return [{"id": "computer", "result": True, "description": " ".join(computer)},
+            {"id": "own", "result": True, "description": " ".join(own)}]
diff --git a/tst/integration/computer/set/envs/desktop/env.toml b/tst/integration/computer/set/envs/desktop/env.toml
new file mode 100644
index 000000000..4b8291877
--- /dev/null
+++ b/tst/integration/computer/set/envs/desktop/env.toml
@@ -0,0 +1,3 @@
+type = "computer"
+computer = "ubuntu-24.04"
+driver = "cua-driver"
diff --git a/tst/integration/computer/set/tasks/tools.json b/tst/integration/computer/set/tasks/tools.json
new file mode 100644
index 000000000..8b68ac46a
--- /dev/null
+++ b/tst/integration/computer/set/tasks/tools.json
@@ -0,0 +1,6 @@
+[
+  {"id": "env", "type": "deploy_env", "env_id": "desktop"},
+  {"id": "tools", "type": "env_outcome_verifier", "env_id": "desktop", "file_artifact_id": "check_tools", "verifier_id": "tools", "depends_on": ["env"]},
+  {"id": "reset", "type": "reset_env", "env_id": "desktop", "depends_on": ["tools"], "fail_task_on_error": true},
+  {"id": "again", "type": "env_outcome_verifier", "env_id": "desktop", "file_artifact_id": "check_tools", "verifier_id": "again", "depends_on": ["reset"]}
+]
diff --git a/tst/integration/computer/set_test.py b/tst/integration/computer/set_test.py
new file mode 100644
index 000000000..339fc7ee9
--- /dev/null
+++ b/tst/integration/computer/set_test.py
@@ -0,0 +1,84 @@
+"""``agent-env run --set`` and a computer env's ``tools`` on real computers, through the set test bundle's desktop (the
+ubuntu-24.04 base with cua-driver) and its task, which lists what the agents' role sees, resets the computer and lists it
+again: each ``tools`` value against cua-driver on local Docker, before and after the reset; another driver set for the
+run, written and composed under the variant's id while the bundle's own env stays unwritten; and ``tools`` on a Modal VM,
+reset in place. Needs Docker and the local registry on localhost:5000; the last test needs Modal credentials too, with
+``[sandbox.attribution]`` tags for Modal's apps."""
+
+import json
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner
+
+import agent_env
+from agent_env.cli import cli
+from agent_env.env import Env
+from agent_env.store.base import NotFoundError
+from agent_env.store.routing import namespace_routing
+from tst.integration.computer.conftest import run_context
+from tst.util.capabilities import skip_without_remote_sandbox
+
+pytestmark = [pytest.mark.integration, pytest.mark.int_test_slow]
+
+BUNDLE = Path(__file__).parent / "set"
+MANIFEST = Path(agent_env.__file__).parent / "drivers" / "envs" / "cua-driver" / "mcp.json"
+CUA_DRIVER_TOOLS = {tool["name"] for tool in json.loads(MANIFEST.read_text())["tools"]}
+COMPUTER_TOOLS = {"computer_screenshot", "computer_click", "computer_drag", "computer_scroll", "computer_type",
+                  "computer_key", "computer_wait"}
+REFERENCE = "@local/agentenv-framework/drivers/reference"
+
+
+@pytest.mark.parametrize("tools, computer, own", [
+    (None, COMPUTER_TOOLS, CUA_DRIVER_TOOLS),
+    ("standard", COMPUTER_TOOLS, set()),
+    ("driver", set(), CUA_DRIVER_TOOLS),
+], ids=["unset", "standard", "driver"])
+def test_a_computer_envs_tools_are_what_its_agents_see_at_deploy_and_after_a_reset(state, tools, computer, own):
+    settings = ["--set", f"envs/desktop.tools={tools}"] if tools else []
+
+    ran = CliRunner().invoke(cli, ["run", str(BUNDLE), "--task", "tools", *settings])
+
+    assert ran.exit_code == 0, ran.output
+    context = run_context(ran.output)
+    assert _seen(context, "tools") == _seen(context, "again") == (computer, own)
+
+
+def test_set_runs_the_bundles_computer_env_with_another_driver_under_an_id_of_its_own(state):
+    ran = CliRunner().invoke(cli, ["run", str(BUNDLE), "--task", "tools", "--set", "envs/desktop.driver=reference"])
+
+    assert ran.exit_code == 0, ran.output
+    assert ("--set envs/desktop.driver=reference: 1 env and 1 task written under ids ending in (desktop.driver "
+            "reference)") in ran.output
+    context = run_context(ran.output)
+    (deployed,) = context["deployed_envs"]
+    variant = deployed["env_id"]
+    assert variant.endswith("/desktop(desktop.driver reference)")
+    with namespace_routing():
+        assert Env.get(variant).driver.id == REFERENCE
+        with pytest.raises(NotFoundError):
+            Env.get(variant.removesuffix("(desktop.driver reference)"))
+    computer, own = _seen(context, "tools")
+    assert COMPUTER_TOOLS <= computer and not own
+
+
+@skip_without_remote_sandbox("modal_vm")
+def test_a_computer_envs_tools_hold_on_a_modal_vm_through_a_reset_in_place(state, monkeypatch):
+    monkeypatch.setenv("XDG_CACHE_HOME", str(state / "cache"))
+
+    ran = CliRunner().invoke(cli, ["run", str(BUNDLE), "--task", "tools", "--sandbox", "modal_vm", "--set",
+                                   "envs/desktop.tools=standard"])
+
+    assert ran.exit_code == 0, ran.output
+    context = run_context(ran.output)
+    (deployed,) = context["deployed_envs"]
+    assert (deployed["sandbox_type"], deployed["metadata"]["computer"]["form"]) == ("modal_vm", "disk")
+    assert deployed["env_id"].endswith("/desktop(desktop.tools standard)")
+    assert _seen(context, "tools") == _seen(context, "again") == (COMPUTER_TOOLS, set())
+
+
+def _seen(context: dict, verifier: str) -> tuple[set[str], set[str]]:
+    """The computer_* tools and the driver's own that the verifier ``verifier`` found the agents' role offered."""
+    results = {result["id"]: set(result["description"].split()) for result in
+               context["metadata"]["verifications"][verifier]["results"]}
+    return results["computer"], results["own"]
diff --git a/tst/unit/env/envs/test_disk_recipe.py b/tst/unit/env/envs/test_disk_recipe.py
index 2db19a883..7aeeadf21 100644
--- a/tst/unit/env/envs/test_disk_recipe.py
+++ b/tst/unit/env/envs/test_disk_recipe.py
@@ -453,12 +453,12 @@ def run(argv, stdin=None, stdout=None, **kwargs):
     monkeypatch.setattr(local_disk.subprocess, "run", run)
     first = "localhost:5000/agentenv-computers:" + "1" * 64 + "@sha256:" + "a" * 64
 
-    exported = [local_disk.exported_disk(image) for image in (first, first, first.replace("1", "2"))]
+    exported = [local_disk.exported_disk(image, "linux/amd64") for image in (first, first, first.replace("1", "2"))]
 
     assert exported[0] == exported[1] != exported[2] and exported[0].parent == tmp_path / "cache" / "agentenv" / "disks"
     assert exported[0].read_bytes() == b"zstd:disk of container1:/disk/disk.img" and exported[0].name.endswith(".img.zst")
     assert [args[0] for args in ran] == ["login", "create", "cp", "login", "create", "cp"]
-    assert ran[0] == ("login", f"credentials for {first}") and ran[1][1:] == (first, "disk")
+    assert ran[0] == ("login", f"credentials for {first}") and ran[1][1:] == ("--platform", "linux/amd64", first, "disk")
     assert compressed[0] == ["docker", "run", "--rm", "-i", "--entrypoint", "zstd", "agentenv-qemu-launcher:src-1",
                              "-q", "-3", "-T0", "-c"] and len(compressed) == 2
     assert sorted(p.name for p in exported[0].parent.iterdir()) == sorted({exported[0].name, exported[2].name})
diff --git a/tst/unit/providers/sandbox_providers/modal_create_signature_test.py b/tst/unit/providers/sandbox_providers/modal_create_signature_test.py
index 1b97f2eca..509857c4e 100644
--- a/tst/unit/providers/sandbox_providers/modal_create_signature_test.py
+++ b/tst/unit/providers/sandbox_providers/modal_create_signature_test.py
@@ -62,7 +62,7 @@ def _provider(cls, **kwargs):
 def _exported_disk(tmp_path, monkeypatch):
     """A disk's export on this machine, and the launcher's image, without Docker or a registry."""
     (tmp_path / "disk.img.zst").write_bytes(b"disk")
-    monkeypatch.setattr(modal_vm_sandbox, "exported_disk", lambda image: tmp_path / "disk.img.zst")
+    monkeypatch.setattr(modal_vm_sandbox, "exported_disk", lambda image, platform: tmp_path / "disk.img.zst")
     monkeypatch.setattr(modal_vm_sandbox, "published_digest", lambda image: "sha256:" + "b" * 64)
 
 
diff --git a/tst/unit/providers/sandbox_providers/modal_vm_sandbox_test.py b/tst/unit/providers/sandbox_providers/modal_vm_sandbox_test.py
index c7d606c6e..00abfa117 100644
--- a/tst/unit/providers/sandbox_providers/modal_vm_sandbox_test.py
+++ b/tst/unit/providers/sandbox_providers/modal_vm_sandbox_test.py
@@ -442,7 +442,8 @@ async def create(*command, **kwargs):
 
     monkeypatch.setattr(mvs.modal.Sandbox, "_experimental_create", SimpleNamespace(aio=create))
     monkeypatch.setattr(mvs.modal.Secret, "from_dict", lambda variables: made.secrets.append(variables) or variables)
-    monkeypatch.setattr(mvs, "exported_disk", lambda image: made.exported.append(image) or Path("/cache/disk.img.zst"))
+    monkeypatch.setattr(mvs, "exported_disk", lambda image, platform: made.exported.append((image, platform))
+                        or Path("/cache/disk.img.zst"))
     monkeypatch.setattr(mvs, "_launcher", AsyncMock(return_value=made.launcher))
     monkeypatch.setattr(mvs, "_log_sandbox_started", AsyncMock())
     return made
@@ -467,7 +468,7 @@ async def test_a_disk_boots_in_a_vm_sandbox_whose_image_is_the_launcher_with_the
                                              cpu=2, memory=4096, timeout=3600)
 
     ((command, kwargs),) = modal_fake.creates
-    assert modal_fake.exported == [DISK_IMAGE]
+    assert modal_fake.exported == [(DISK_IMAGE, "linux/amd64")]
     modal_fake.launcher.add_local_file.assert_called_once_with(Path("/cache/disk.img.zst"), "/disk/disk.img.zst",
                                                                copy=False)
     assert command == ("/usr/local/bin/launch",) and kwargs["image"] is modal_fake.launcher.add_local_file.return_value