feat(supervise+orchestrator): slice 11 — per-bottle supervise queue + DLP safelist

Consolidated egress ran every bottle through one process but keyed the
supervise proposal queue off a single SUPERVISE_BOTTLE_SLUG env and kept
one *global* DLP safelist — so in the shared gateway an operator's token
approval for bottle A would (a) be attributed to the wrong bottle and
(b) leak into bottle B's DLP scan (A's approved secret passes B's egress).
This slice keys both per bottle, resolved by source IP.

- policy_resolver: add `resolve_policy_and_bottle_id` — policy + bottle id
  in one `/resolve`, so egress keys routing *and* the supervise
  queue/safelist from a single round-trip. Fail-closed (403 -> (None,None)).
- egress_addon_core: add `resolve_client_context` (+ `ContextResolverLike`)
  returning `(Config, bottle_id)`, sharing the fail-closed parse with
  `resolve_client_config` via `_config_from_policy`.
- egress_addon: `_active_config` -> `_resolve_flow` returns `(Config, slug)`;
  `safe_tokens` set -> per-bottle `_safe_tokens_for(slug)`; the token-allow
  write/await/archive + the approved-token add all use the resolved slug.
  Single-tenant (no resolver) unchanged — slug = the env SUPERVISE_BOTTLE_SLUG.

New tests cover the resolver, the fail-closed context matrix, and the
cross-tenant isolation (an approval lands only in the calling bottle's
safelist; the proposal is keyed by the source-IP-attributed bottle;
unattributed IPs can't supervise).

Out of scope (noted): the git-gate gitleaks-allow hook + supervise_server
agent-proposal paths, and websocket DLP (still self.config-only, inert in
consolidated mode) — follow-up slices.

pyright 0 errors; pylint 9.83/10; unit suite green (1700 tests; the 13
test_sidecar_init /bin/sleep errors are pre-existing NixOS-local noise).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WBMWTEtQdJ4W5UrWuLHCck

README.md

@@ -5,7 +5,7 @@
 # bot-bottle
 
 [![test](https://gitea.dideric.is/didericis/bot-bottle/actions/workflows/test.yml/badge.svg?branch=main)](https://gitea.dideric.is/didericis/bot-bottle/actions?workflow=test.yml)
-[![coverage](https://img.shields.io/badge/coverage-83%25-brightgreen)](https://coverage.readthedocs.io/)
+[![coverage](https://img.shields.io/badge/coverage-82%25-brightgreen)](https://coverage.readthedocs.io/)
 [![core coverage](https://img.shields.io/badge/core%20coverage-95%25-brightgreen)](https://gitea.dideric.is/didericis/bot-bottle/src/branch/main/docs/decisions/0004-coverage-policy.md)
 
 **Problem:** Developer wants to run a coding agent without supervision, but they don't want a prompt injected or misbehaving agent wrecking their environment or exfiltrating sensitive data.

bot_bottle/agent_provider.py

@@ -61,13 +61,6 @@ class AgentProviderRuntime:
     prompt_mode: PromptMode
     bypass_args: tuple[str, ...]
     resume_args: tuple[str, ...]
-    # argv run inside a throwaway container of a freshly built agent
-    # image, right after `build_image()`, to catch a build that
-    # exited 0 but produced a broken CLI (e.g. an npm
-    # optionalDependencies fetch for a platform-native binary that
-    # silently no-ops on a transient failure). Empty tuple skips the
-    # check — not every provider has opted in yet.
-    smoke_test: tuple[str, ...] = ()
 
 
 @dataclass(frozen=True)

bot_bottle/backend/docker/backend.py

@@ -111,11 +111,6 @@ class DockerBottleBackend(BottleBackend["DockerBottlePlan", "DockerBottleCleanup
         plumbing needed; the alias resolves inside the bridge."""
         if plan.supervise_plan is None:
             return ""
-        # Consolidated: the supervise daemon lives on the shared gateway, so
-        # the agent registers the gateway address (NO_PROXY bypasses egress),
-        # not the per-bottle `supervise` alias.
-        if plan.agent_supervise_url:
-            return plan.agent_supervise_url
         return f"http://{SUPERVISE_HOSTNAME}:{SUPERVISE_PORT}/"
 
     def prepare_cleanup(self) -> DockerBottleCleanupPlan:

bot_bottle/backend/docker/bottle_plan.py

@@ -28,30 +28,11 @@ class DockerBottlePlan(BottlePlan):
     # accidental log of the plan dataclass.
     forwarded_env: dict[str, str] = field(repr=False)
     use_runsc: bool
-    # Consolidated mode (PRD 0070): the agent reaches git-gate over HTTP at the
-    # shared gateway's address (`http://<gateway_ip>:9420`), set at launch.
-    # Empty → single-tenant defaults (the `git-gate` alias over git://).
-    agent_git_gate_url: str = ""
-    # Likewise the supervise MCP endpoint at the gateway (`http://<gw>:9100/`);
-    # empty → the single-tenant `supervise` alias.
-    agent_supervise_url: str = ""
 
     @property
     def container_name(self) -> str:
         return self.agent_provision.instance_name
 
-    @property
-    def git_gate_insteadof_host(self) -> str:
-        if self.agent_git_gate_url.startswith("http://"):
-            return self.agent_git_gate_url.removeprefix("http://").rstrip("/")
-        return super().git_gate_insteadof_host
-
-    @property
-    def git_gate_insteadof_scheme(self) -> str:
-        if self.agent_git_gate_url.startswith("http://"):
-            return "http"
-        return super().git_gate_insteadof_scheme
-
     @property
     def image(self) -> str:
         return self.agent_provision.image

bot_bottle/backend/docker/consolidated_compose.py

@@ -1,78 +0,0 @@
-"""Agent-only compose for the consolidated docker backend (PRD 0070).
-
-The per-bottle model rendered a compose project with the agent *and* a
-sidecar bundle on two per-bottle networks. In the consolidated model the
-sidecars are gone — one shared gateway serves every bottle — so this renders
-just the agent, attached to the **external shared gateway network** with the
-pinned source IP the orchestrator allocated, and pointed at the gateway's
-address for egress (and, around the proxy, for git-http / supervise).
-
-Pure: it takes the launch-time `LaunchContext` values (gateway address,
-source IP, network) and the prepared plan, and returns a compose dict — no
-docker, so it's testable in isolation.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from ...egress import egress_agent_env_entries
-from ..util import AGENT_CA_BUNDLE, AGENT_CA_PATH
-from .bottle_plan import DockerBottlePlan
-from .egress import EGRESS_PORT
-
-
-def consolidated_agent_compose(
-    plan: DockerBottlePlan,
-    *,
-    gateway_ip: str,
-    source_ip: str,
-    network: str,
-) -> dict[str, Any]:
-    """A compose spec with only the agent service, on the external gateway
-    network at `source_ip`, proxying egress through `gateway_ip`."""
-    proxy_url = f"http://{gateway_ip}:{EGRESS_PORT}"
-    # git-http + supervise live on the gateway too and must NOT go through the
-    # egress proxy — the agent reaches them directly by the gateway address.
-    no_proxy = f"localhost,127.0.0.1,{gateway_ip}"
-    env: list[str] = [
-        f"HTTPS_PROXY={proxy_url}",
-        f"HTTP_PROXY={proxy_url}",
-        f"https_proxy={proxy_url}",
-        f"http_proxy={proxy_url}",
-        f"NO_PROXY={no_proxy}",
-        f"no_proxy={no_proxy}",
-        f"NODE_EXTRA_CA_CERTS={AGENT_CA_PATH}",
-        f"SSL_CERT_FILE={AGENT_CA_BUNDLE}",
-        f"REQUESTS_CA_BUNDLE={AGENT_CA_BUNDLE}",
-    ]
-    for name, value in sorted(plan.agent_provision.guest_env.items()):
-        env.append(f"{name}={value}")
-    # Forwarded vars: bare name → inherits from the compose-up process env so
-    # the secret value never lands on argv or in the compose file.
-    for name in sorted(plan.forwarded_env.keys()):
-        env.append(name)
-    env.extend(egress_agent_env_entries(plan.egress_plan))
-
-    service: dict[str, Any] = {
-        "image": plan.image,
-        "container_name": plan.container_name,
-        "command": ["sleep", "infinity"],
-        # Pinned address on the shared gateway network — the orchestrator
-        # registered this IP, and the gateway attributes the bottle by it.
-        "networks": {network: {"ipv4_address": source_ip}},
-        "environment": env,
-    }
-    if plan.use_runsc:
-        service["runtime"] = "runsc"
-
-    return {
-        "name": f"bot-bottle-{plan.slug}",
-        "services": {"agent": service},
-        # The gateway network is created + owned by the orchestrator; compose
-        # attaches to it (external) and must not create or destroy it.
-        "networks": {network: {"external": True}},
-    }
-
-
-__all__ = ["consolidated_agent_compose"]

bot_bottle/backend/docker/consolidated_launch.py

@@ -1,153 +0,0 @@
-"""Consolidated bottle launch sequence for the docker backend (PRD 0070).
-
-Composes the orchestrator primitives into the register/teardown sequence that
-replaces the per-bottle sidecar bundle:
-
-  1. ensure the orchestrator control plane + shared gateway are up;
-  2. allocate the bottle a pinned source IP on the gateway network (the
-     attribution key), skipping the gateway's own address + live bottles;
-  3. register it (egress policy blob + slug metadata) → bottle id + identity
-     token;
-  4. provision its git-gate repos/creds into the running gateway.
-
-It returns a `LaunchContext` with everything the agent container needs to
-attach — network, pinned IP, the gateway's address (its proxy target), the
-orchestrator URL, and the identity token. The agent `docker run` itself is
-the backend's job (it owns provider provisioning); this owns the
-orchestrator-facing wiring so that sequence stays testable in isolation.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from ...docker_cmd import run_docker
-from ...egress import EgressPlan
-from ...git_gate import GitGatePlan
-from ...orchestrator.client import OrchestratorClient
-from ...orchestrator.gateway import GATEWAY_NAME, GATEWAY_NETWORK
-from ...orchestrator.lifecycle import OrchestratorService
-from ...orchestrator.registration import registration_inputs
-from .gateway_net import next_free_ip
-from .gateway_provision import deprovision_git_gate, provision_git_gate
-
-
-class ConsolidatedLaunchError(RuntimeError):
-    """The consolidated register/provision sequence could not complete."""
-
-
-@dataclass(frozen=True)
-class LaunchContext:
-    """What the agent container needs to join the shared gateway."""
-
-    bottle_id: str
-    identity_token: str
-    source_ip: str          # the agent's pinned address (attribution key)
-    network: str            # the shared gateway network to attach to
-    gateway_ip: str         # the gateway's address — the agent's proxy target
-    orchestrator_url: str
-
-
-def _network_cidr(network: str) -> str:
-    """The gateway network's IPv4 subnet, or raise."""
-    proc = run_docker([
-        "docker", "network", "inspect",
-        "--format", "{{range .IPAM.Config}}{{.Subnet}}{{end}}", network,
-    ])
-    cidr = proc.stdout.strip()
-    if proc.returncode != 0 or not cidr:
-        raise ConsolidatedLaunchError(
-            f"gateway network {network} has no subnet: {proc.stderr.strip()}"
-        )
-    return cidr
-
-
-def _container_ip(name: str, network: str) -> str:
-    """A container's IPv4 address on `network`, or raise."""
-    proc = run_docker([
-        "docker", "inspect", "--format",
-        f'{{{{(index .NetworkSettings.Networks "{network}").IPAddress}}}}', name,
-    ])
-    ip = proc.stdout.strip()
-    if proc.returncode != 0 or not ip:
-        raise ConsolidatedLaunchError(
-            f"gateway {name} has no address on {network}: {proc.stderr.strip()}"
-        )
-    return ip
-
-
-def _network_container_ips(network: str) -> list[str]:
-    """Every address currently assigned on the gateway network — the ground
-    truth for "in use": the gateway + orchestrator infrastructure containers
-    and every live agent. Read from the network so a new bottle can't collide
-    with anything actually attached (a registry-only view would miss the
-    orchestrator/gateway containers)."""
-    proc = run_docker([
-        "docker", "network", "inspect", "--format",
-        "{{range .Containers}}{{.IPv4Address}} {{end}}", network,
-    ])
-    ips: list[str] = []
-    for entry in proc.stdout.split():
-        # entries look like "172.20.0.2/16" — keep the address.
-        ips.append(entry.split("/", 1)[0])
-    return ips
-
-
-def launch_consolidated(
-    egress_plan: EgressPlan,
-    git_gate_plan: GitGatePlan,
-    *,
-    image_ref: str = "",
-    tokens: dict[str, str] | None = None,
-    service: OrchestratorService | None = None,
-    gateway_name: str = GATEWAY_NAME,
-    network: str = GATEWAY_NETWORK,
-) -> LaunchContext:
-    """Ensure the orchestrator + gateway are up, allocate + register the
-    bottle, and provision its git-gate state. Returns the agent's attach
-    context. Raises `ConsolidatedLaunchError` (or the primitives' own errors)
-    if any step fails — the caller tears down on failure."""
-    service = service or OrchestratorService()
-    url = service.ensure_running()
-    client = OrchestratorClient(url)
-
-    cidr = _network_cidr(network)
-    gateway_ip = _container_ip(gateway_name, network)
-    source_ip = next_free_ip(cidr, _network_container_ips(network))
-
-    inputs = registration_inputs(egress_plan)
-    reg = client.register_bottle(
-        source_ip, image_ref=image_ref, policy=inputs.policy,
-        metadata=inputs.metadata, tokens=tokens,
-    )
-    try:
-        provision_git_gate(gateway_name, reg.bottle_id, git_gate_plan)
-    except Exception:
-        # Roll the registration back so a provisioning failure leaves no orphan.
-        client.teardown_bottle(reg.bottle_id)
-        raise
-    return LaunchContext(
-        bottle_id=reg.bottle_id,
-        identity_token=reg.identity_token,
-        source_ip=source_ip,
-        network=network,
-        gateway_ip=gateway_ip,
-        orchestrator_url=url,
-    )
-
-
-def teardown_consolidated(
-    bottle_id: str, *, orchestrator_url: str, gateway_name: str = GATEWAY_NAME,
-) -> None:
-    """Deregister the bottle and remove its git-gate state from the gateway.
-    Both steps are idempotent so this is safe from a cleanup trap."""
-    OrchestratorClient(orchestrator_url).teardown_bottle(bottle_id)
-    deprovision_git_gate(gateway_name, bottle_id)
-
-
-__all__ = [
-    "LaunchContext",
-    "launch_consolidated",
-    "teardown_consolidated",
-    "ConsolidatedLaunchError",
-]

bot_bottle/backend/docker/gateway_net.py

@@ -1,47 +0,0 @@
-"""Shared-gateway source-IP allocation for the consolidated docker backend
-(PRD 0070).
-
-In the consolidated model one gateway container serves every bottle over a
-single shared docker network, and each agent bottle attaches with a pinned,
-deterministic address that the gateway uses as its **attribution key**. This
-allocates those addresses from the network's subnet, skipping the reserved
-ones — the network address and broadcast (excluded by `hosts()`), docker's
-router `.1`, and everything already in use (`taken`: the gateway container
-plus every live bottle, which the caller reads from the registry).
-
-Pure `ipaddress` logic — the docker-specific bits (the subnet CIDR, the
-gateway container's own address) are gathered by the caller and passed in, so
-this stays testable without docker.
-"""
-
-from __future__ import annotations
-
-import ipaddress
-from collections.abc import Iterable
-
-
-class NoFreeAddressError(RuntimeError):
-    """The shared gateway network's subnet is exhausted — every host address
-    is reserved or already assigned to a bottle."""
-
-
-def next_free_ip(cidr: str, taken: Iterable[str]) -> str:
-    """The lowest host address in `cidr` not in `taken` and not docker's
-    router (`.1`). `taken` must include the gateway container's own address
-    and every live bottle's. Raises `NoFreeAddressError` if the subnet is
-    full."""
-    net = ipaddress.ip_network(cidr, strict=False)
-    reserved = {str(a) for a in taken}
-    # Docker assigns the network's first host (.1) to the bridge router; a
-    # bottle must never be handed that address.
-    reserved.add(str(net.network_address + 1))
-    for host in net.hosts():  # hosts() already excludes network + broadcast
-        candidate = str(host)
-        if candidate not in reserved:
-            return candidate
-    raise NoFreeAddressError(
-        f"no free address in {cidr} ({len(reserved)} reserved/assigned)"
-    )
-
-
-__all__ = ["next_free_ip", "NoFreeAddressError"]

bot_bottle/backend/docker/gateway_provision.py

@@ -1,100 +0,0 @@
-"""Provision one bottle's git-gate state into the running shared gateway
-(PRD 0070, docker slice).
-
-The consolidated gateway serves every bottle's repos under `/git/<bottle_id>/`
-with per-repo credentials under `/git-gate/creds/<bottle_id>/`. When a bottle
-is registered the launcher must place *its* deploy keys + known_hosts into
-that per-bottle creds dir and init its bare repos there — so this copies the
-credential files into the live gateway container and runs the (namespaced,
-init-only) provisioning script produced by `git_gate_render_provision`.
-
-Isolating each bottle's creds dir + repo root by id is what keeps one
-bottle's push credentials out of another's repos on the shared gateway.
-"""
-
-from __future__ import annotations
-
-import re
-
-from ...docker_cmd import run_docker
-from ...git_gate import GitGatePlan, git_gate_render_provision
-
-# bottle ids index the gateway's per-bottle repo + creds dirs; they land in
-# `docker cp`/`rm` path arguments, so validate before any path is built (a
-# traversal id like "../etc" must never reach the container). Registry ids are
-# token_hex — this is defense in depth at the docker boundary.
-_SAFE_BOTTLE_ID = re.compile(r"[A-Za-z0-9_-]+")
-
-
-class GatewayProvisionError(RuntimeError):
-    """A git-gate provisioning step against the running gateway failed."""
-
-
-def _require_safe(bottle_id: str) -> None:
-    if not _SAFE_BOTTLE_ID.fullmatch(bottle_id):
-        raise GatewayProvisionError(f"unsafe bottle id {bottle_id!r}")
-
-
-def _creds_dir(bottle_id: str) -> str:
-    return f"/git-gate/creds/{bottle_id}"
-
-
-def _exec(gateway: str, argv: list[str]) -> None:
-    """`docker exec` a command in the gateway, raising on non-zero exit."""
-    proc = run_docker(["docker", "exec", gateway, *argv])
-    if proc.returncode != 0:
-        raise GatewayProvisionError(
-            f"gateway exec {argv!r} failed: {proc.stderr.strip()}"
-        )
-
-
-def _cp_into(gateway: str, src: str, dest: str) -> None:
-    """`docker cp` a host file into the gateway, raising on non-zero exit."""
-    proc = run_docker(["docker", "cp", src, f"{gateway}:{dest}"])
-    if proc.returncode != 0:
-        raise GatewayProvisionError(
-            f"gateway cp {src} -> {dest} failed: {proc.stderr.strip()}"
-        )
-
-
-def provision_git_gate(gateway: str, bottle_id: str, plan: GitGatePlan) -> None:
-    """Place `bottle_id`'s git-gate credentials into the running `gateway`
-    container and init its bare repos under `/git/<bottle_id>/`.
-
-    Copies each upstream's identity key (and known_hosts, when present) into
-    `/git-gate/creds/<bottle_id>/`, then runs the namespaced provisioning
-    script. No-op for a bottle with no git upstreams."""
-    _require_safe(bottle_id)
-    if not plan.upstreams:
-        return
-    # The pre-receive + access hooks are bottle-agnostic and shared by every
-    # bottle's repos; install them into the gateway (idempotent — same content
-    # each time). The per-bottle model cp'd these into each bundle at start.
-    _exec(gateway, ["mkdir", "-p", "/etc/git-gate"])
-    _cp_into(gateway, str(plan.hook_script), "/etc/git-gate/pre-receive")
-    _cp_into(gateway, str(plan.access_hook_script), "/etc/git-gate/access-hook")
-    creds = _creds_dir(bottle_id)
-    _exec(gateway, ["mkdir", "-p", creds])
-    for u in plan.upstreams:
-        if u.identity_file:
-            _cp_into(gateway, u.identity_file, f"{creds}/{u.name}-key")
-        known_hosts = str(u.known_hosts_file)
-        if known_hosts and known_hosts != ".":
-            _cp_into(gateway, known_hosts, f"{creds}/{u.name}-known_hosts")
-    # Init the bare repos + per-repo credential config for this namespace.
-    script = git_gate_render_provision(bottle_id, plan.upstreams)
-    _exec(gateway, ["sh", "-c", script])
-
-
-def deprovision_git_gate(gateway: str, bottle_id: str) -> None:
-    """Remove a bottle's repos + creds from the gateway on teardown. Idempotent
-    — an already-absent namespace is a clean no-op (best effort; a stray dir
-    can't leak, since attribution is by source IP and the bottle is gone)."""
-    _require_safe(bottle_id)
-    run_docker([
-        "docker", "exec", gateway, "rm", "-rf",
-        f"/git/{bottle_id}", _creds_dir(bottle_id),
-    ])
-
-
-__all__ = ["provision_git_gate", "deprovision_git_gate", "GatewayProvisionError"]

bot_bottle/backend/docker/launch.py

@@ -36,13 +36,13 @@ from contextlib import ExitStack, contextmanager
 from pathlib import Path
 from typing import Callable, Generator
 
-from ...agent_provider import runtime_for
 from ...egress import egress_resolve_token_values
 from ...git_gate import (
     provision_git_gate_dynamic_keys,
     revoke_git_gate_provisioned_keys,
 )
 from ...log import info, warn
+from . import network as network_mod
 from . import util as docker_mod
 from .bottle import DockerBottle
 from .bottle_plan import DockerBottlePlan
@@ -53,6 +53,7 @@ from ...bottle_state import (
     read_committed_image,
 )
 from .compose import (
+    bottle_plan_to_compose,
     compose_down,
     compose_dump_logs,
     compose_file_path,
@@ -61,9 +62,7 @@ from .compose import (
     compose_up,
     write_compose_file,
 )
-from .consolidated_compose import consolidated_agent_compose
-from .consolidated_launch import launch_consolidated, teardown_consolidated
-from ...orchestrator.gateway import DockerGateway
+from .egress import egress_tls_init
 
 
 # Where the repo root lives, for `docker build` context. Computed once.
@@ -98,7 +97,8 @@ def launch(
     try:
         # Step 1: agent image. Use a committed snapshot when one exists
         # and is present in the local daemon; otherwise build from the
-        # Dockerfile. (The gateway image is built by the orchestrator.)
+        # Dockerfile. Sidecar images get built lazily by `docker compose
+        # up` via the renderer's `build:` directives.
         committed = read_committed_image(plan.slug)
         if committed and docker_mod.image_exists(committed):
             info(f"using committed image {committed!r}")
@@ -111,86 +111,83 @@ def launch(
                 plan.image, _REPO_DIR,
                 dockerfile=plan.dockerfile_path,
             )
-            docker_mod.verify_agent_image(
-                plan.image, runtime_for(plan.agent_provider_template).smoke_test,
-            )
 
-        # Step 2: mint the git-gate dynamic (gitea) deploy keys, if any, before
-        # provisioning the bottle's repos into the shared gateway.
+        internal_network = network_mod.network_name_for_slug(plan.slug)
+        egress_network = network_mod.network_egress_name_for_slug(plan.slug)
+
+        egress_ca_host, egress_ca_cert_only = egress_tls_init(
+            egress_state_dir(plan.slug),
+        )
+
         git_gate_plan = plan.git_gate_plan
         if git_gate_plan.upstreams:
             git_gate_plan = provision_git_gate_dynamic_keys(
-                plan.manifest.bottle, git_gate_plan, git_gate_state_dir(plan.slug),
+                plan.manifest.bottle,
+                git_gate_plan,
+                git_gate_state_dir(plan.slug),
+            )
+            git_gate_plan = dataclasses.replace(
+                git_gate_plan,
+                internal_network=internal_network,
+                egress_network=egress_network,
             )
-
-        # Step 3: register on the orchestrator + provision this bottle's
-        # git-gate state into the shared gateway; get the agent's attach
-        # context (pinned source IP, gateway address, shared network). The
-        # per-bottle egress auth tokens are resolved from the host env now and
-        # handed to the orchestrator (in memory) for the gateway to inject —
-        # the agent never sees them.
-        effective_env = {**os.environ, **plan.agent_provision.provisioned_env}
-        token_values = egress_resolve_token_values(
-            plan.egress_plan.token_env_map, effective_env,
-        )
-        ctx = launch_consolidated(
-            plan.egress_plan, git_gate_plan, image_ref=plan.image, tokens=token_values,
-        )
-        stack.callback(
-            teardown_consolidated, ctx.bottle_id, orchestrator_url=ctx.orchestrator_url,
-        )
-
-        # Step 4: install the SHARED gateway CA into the agent (replaces the
-        # per-bottle CA) — read it out of the running gateway.
-        ca_dir = egress_state_dir(plan.slug) / "gateway-ca"
-        ca_dir.mkdir(parents=True, exist_ok=True)
-        ca_file = ca_dir / "gateway-ca.pem"
-        ca_file.write_text(DockerGateway(network=ctx.network).ca_cert_pem())
         egress_plan = dataclasses.replace(
             plan.egress_plan,
-            mitmproxy_ca_host_path=ca_file,
-            mitmproxy_ca_cert_only_host_path=ca_file,
-        )
-        # Point the agent's git-gate insteadOf rewrites at the shared gateway's
-        # HTTP git endpoint (9420) instead of the dead per-bottle `git-gate`
-        # alias. git-http + supervise on the gateway bypass the egress proxy
-        # (NO_PROXY includes the gateway address).
-        git_gate_url = (
-            f"http://{ctx.gateway_ip}:9420" if git_gate_plan.upstreams else ""
-        )
-        supervise_url = (
-            f"http://{ctx.gateway_ip}:9100/" if plan.supervise_plan is not None else ""
+            internal_network=internal_network,
+            egress_network=egress_network,
+            mitmproxy_ca_host_path=egress_ca_host,
+            mitmproxy_ca_cert_only_host_path=egress_ca_cert_only,
         )
+        supervise_plan = plan.supervise_plan
+        if supervise_plan is not None:
+            supervise_plan = dataclasses.replace(
+                supervise_plan,
+                internal_network=internal_network,
+            )
         plan = dataclasses.replace(
             plan,
             git_gate_plan=git_gate_plan,
             egress_plan=egress_plan,
-            agent_git_gate_url=git_gate_url,
-            agent_supervise_url=supervise_url,
+            supervise_plan=supervise_plan,
         )
 
-        # Step 5: render + up the agent-only compose, pinned on the shared
-        # gateway network and proxied through the gateway's address.
+        # Step 6: render + write the compose file. metadata.json
+        # was written at prepare time and already carries
+        # compose_project; nothing to update here.
         state_dir = bottle_state_dir(plan.slug)
-        spec = consolidated_agent_compose(
-            plan, gateway_ip=ctx.gateway_ip, source_ip=ctx.source_ip, network=ctx.network,
-        )
+        spec = bottle_plan_to_compose(plan)
         compose_file = write_compose_file(spec, compose_file_path(state_dir))
         project = compose_project_name(plan.slug)
-        # Forwarded vars (OAuth token, host interpolations) flow through the
-        # subprocess env as bare names so values never land in the file.
-        compose_env: dict[str, str] = {**os.environ, **plan.forwarded_env}
+
+        # Step 7: compose up. Token values + the OAuth placeholder
+        # flow through subprocess env; the compose file holds only
+        # bare names for the secret-carrying entries.
+        effective_env = {**dict(os.environ), **plan.agent_provision.provisioned_env}
+        token_values = egress_resolve_token_values(
+            plan.egress_plan.token_env_map, effective_env,
+        )
+        compose_env: dict[str, str] = {
+            **os.environ,
+            **plan.forwarded_env,
+            **token_values,
+        }
         info(
-            f"docker compose up -d  (project {project}, agent on shared "
-            f"gateway {ctx.gateway_ip}, ip {ctx.source_ip})"
+            f"docker compose up -d  (project {project}, "
+            f"{len(spec['services'])} services)"
         )
         compose_up(project, compose_file, env=compose_env)
+
+        # Register teardown in reverse order: log dump first, then
+        # `compose down`. Networks come down last via callbacks
+        # registered in step 2.
         stack.callback(compose_down, project, compose_file)
         stack.callback(
             compose_dump_logs, project, compose_file, compose_log_path(state_dir),
         )
 
-        # Step 6: provision (CA install now uses the gateway CA) + yield.
+        # Step 8: provision. Create the bottle first so provisioners
+        # can use bottle.exec / bottle.cp_in; set the prompt path
+        # returned by provision_prompt after the fact.
         bottle = DockerBottle(
             plan.container_name,
             teardown,
@@ -203,6 +200,10 @@ def launch(
             agent_workdir=plan.workspace_plan.workdir,
         )
         bottle.prompt_path = provision(plan, bottle)
+
+        # Step 9: yield. exec_agent continues to use `docker exec -it`
+        # — the agent runs `sleep infinity` per the renderer's
+        # service spec.
         yield bottle
     finally:
         teardown()

bot_bottle/backend/docker/util.py

@@ -4,13 +4,11 @@ existence, and building images."""
 
 from __future__ import annotations
 
-import os
 import re
 import shutil
 import subprocess
 from typing import Iterable, Iterator
 
-from ...docker_cmd import run_docker
 from ...log import die, info
 # from ...workspace import WorkspacePlan
 
@@ -90,29 +88,6 @@ def docker_exec_root(container: str, argv: list[str]) -> None:
     )
 
 
-def docker_exec(container: str, argv: list[str], *, user: str = "") -> None:
-    """Run `docker exec` in the named container, dying with the
-    command's own stderr on failure. Pass `user=\"0\"` to run as root."""
-    cmd = ["docker", "exec"]
-    if user:
-        cmd += ["-u", user]
-    cmd += [container, *argv]
-    result = run_docker(cmd)
-    if result.returncode != 0:
-        die(
-            f"docker exec in {container} failed: "
-            f"{(result.stderr or '').strip() or '<no stderr>'}"
-        )
-
-
-def docker_cp(src: str, dest: str) -> None:
-    """Run `docker cp`, dying with the command's own stderr on failure."""
-    result = run_docker(["docker", "cp", src, dest])
-    if result.returncode != 0:
-        die(f"docker cp {src} -> {dest} failed: "
-            f"{(result.stderr or '').strip() or '<no stderr>'}")
-
-
 _SLUG_RE = re.compile(r"[^a-z0-9]+")
 
 
@@ -133,40 +108,15 @@ def build_image(ref: str, context: str, *, dockerfile: str = "") -> None:
 
     `dockerfile` is an optional path (relative to `context`, or
     absolute) for callers that need to build from a non-default
-    Dockerfile in the same context — e.g. `Dockerfile.git-gate`.
-
-    Set `BOT_BOTTLE_NO_CACHE=1` (the `start --no-cache` flag) to force
-    `--no-cache`. The npm/curl installers some provider Dockerfiles
-    shell out to can silently no-op on a transient network failure —
-    e.g. an `optionalDependencies` fetch for a platform-native binary —
-    and Docker will then cache that broken layer indefinitely."""
+    Dockerfile in the same context — e.g. `Dockerfile.git-gate`."""
     info(f"building image {ref} from {context} (layer cache keeps repeat builds fast)")
     args = ["docker", "build", "-t", ref]
-    if os.environ.get("BOT_BOTTLE_NO_CACHE") == "1":
-        args.append("--no-cache")
     if dockerfile:
         args.extend(["-f", dockerfile])
     args.append(context)
     subprocess.run(args, check=True)
 
 
-def verify_agent_image(image: str, argv: tuple[str, ...]) -> None:
-    """Run `argv` inside a throwaway container of a freshly built agent
-    image and die loudly if it fails, instead of shipping an image
-    whose CLI only breaks at first real use. No-op when the provider
-    hasn't declared a smoke test (`AgentProviderRuntime.smoke_test`)."""
-    if not argv:
-        return
-    result = run_docker(["docker", "run", "--rm", "--entrypoint", argv[0], image, *argv[1:]])
-    if result.returncode != 0:
-        detail = (result.stderr or result.stdout or "").strip()
-        die(
-            f"agent image {image!r} failed its post-build smoke test "
-            f"({' '.join(argv)}): {detail}\n"
-            f"Try rebuilding from scratch: bot-bottle start --no-cache"
-        )
-
-
 # def build_image_with_cwd(
 #     derived: str,
 #     base: str,

bot_bottle/backend/firecracker/consolidated_launch.py

@@ -1,162 +0,0 @@
-"""Consolidated bottle launch sequence for the Firecracker backend (PRD 0070).
-
-Mirrors bot_bottle.backend.docker.consolidated_launch but wired for
-Firecracker's TAP-based network topology instead of a shared Docker bridge.
-
-The per-bottle sidecar bundle (one `docker run` per bottle, published on the
-slot's host-side TAP IP) is replaced by a single persistent gateway that
-every Firecracker VM shares. The gateway runs as a Docker container in the
-dev-harness (a Firecracker VM is stage B per PRD 0070), with its ports
-published on the host (`0.0.0.0:PORT`). VMs reach it at their slot's
-host-side TAP IP because Docker's iptables PREROUTING DNAT redirects
-port 9099/9100/9420 traffic to the gateway container — a path the nft
-isolation table already allows via `ct status dnat accept` in the forward
-chain.
-
-Attribution is by the VM's guest IP, which is unspoofable by construction:
-the /31 point-to-point TAP topology + the `bot_bottle_fc` nft table ensure
-that only the expected VM can source-IP that address.
-
-Sequence:
-  1. ensure the Firecracker-flavoured orchestrator + gateway are up;
-  2. register the bottle by its guest IP (attribution key) → bottle id +
-     identity token;
-  3. provision its git-gate repos/creds into the running gateway;
-  4. fetch the shared gateway CA for the provisioner to install in the rootfs.
-
-The TAP slot allocation, rootfs build, and VM boot are the caller's job.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from ...egress import EgressPlan
-from ...git_gate import GitGatePlan
-from ...orchestrator.client import OrchestratorClient
-from ...orchestrator.gateway import (
-    GATEWAY_NETWORK,
-    DockerGateway,
-)
-from ...orchestrator.lifecycle import (
-    OrchestratorService,
-    OrchestratorStartError,  # re-exported so callers can catch it
-)
-from ...orchestrator.registration import registration_inputs
-from ..docker.egress import EGRESS_PORT
-from ..docker.gateway_provision import deprovision_git_gate, provision_git_gate
-from ...supervise import SUPERVISE_PORT
-
-_GIT_HTTP_PORT = 9420
-
-# Separate names from the Docker gateway so both backends can coexist on one
-# host (and for clarity in `docker ps` output).
-_FC_GATEWAY_NAME = "bot-bottle-fc-gateway"
-_FC_ORCHESTRATOR_NAME = "bot-bottle-fc-orchestrator"
-_FC_ORCHESTRATOR_LABEL = "bot-bottle-fc-orchestrator=1"
-# Ports the gateway publishes on the host so Firecracker VMs can reach it
-# via their TAP link. Docker's PREROUTING DNAT + nft's `ct status dnat
-# accept` in the forward chain route the traffic.
-_FC_GATEWAY_HOST_PORTS = (EGRESS_PORT, SUPERVISE_PORT, _GIT_HTTP_PORT)
-
-
-class ConsolidatedLaunchError(RuntimeError):
-    """The consolidated register/provision sequence could not complete."""
-
-
-@dataclass(frozen=True)
-class LaunchContext:
-    """What the Firecracker launch needs from the consolidated sequence."""
-
-    bottle_id: str
-    identity_token: str
-    source_ip: str          # the VM's guest IP — the attribution key
-    gateway_ca_pem: str     # the shared gateway CA the provisioner installs
-    orchestrator_url: str
-
-
-class _FirecrackerOrchestratorService(OrchestratorService):
-    """Dev-harness orchestrator for the Firecracker backend.
-
-    Uses a gateway that publishes its ports on the host so Firecracker VMs can
-    reach it via their TAP link. The gateway and orchestrator containers use
-    `*-fc-*` names so both backends can run independently on the same host.
-    """
-
-    def __init__(self, **kwargs: object) -> None:
-        super().__init__(
-            orchestrator_name=_FC_ORCHESTRATOR_NAME,
-            orchestrator_label=_FC_ORCHESTRATOR_LABEL,
-            **kwargs,  # type: ignore[arg-type]
-        )
-
-    def _gateway(self) -> DockerGateway:
-        return DockerGateway(
-            self.image,
-            name=_FC_GATEWAY_NAME,
-            network=self.network,
-            orchestrator_url=self.internal_url,
-            host_port_bindings=_FC_GATEWAY_HOST_PORTS,
-        )
-
-
-def launch_consolidated(
-    egress_plan: EgressPlan,
-    git_gate_plan: GitGatePlan,
-    *,
-    guest_ip: str,
-    image_ref: str = "",
-    tokens: dict[str, str] | None = None,
-    service: OrchestratorService | None = None,
-    gateway_name: str = _FC_GATEWAY_NAME,
-) -> LaunchContext:
-    """Ensure the orchestrator + Firecracker gateway are up, register the
-    bottle by its guest IP, and provision its git-gate state. Returns the
-    context the VM launch needs. Raises `ConsolidatedLaunchError` (or the
-    primitives' own errors) on failure — the caller tears down on failure."""
-    service = service or _FirecrackerOrchestratorService()
-    url = service.ensure_running()
-    client = OrchestratorClient(url)
-
-    inputs = registration_inputs(egress_plan)
-    reg = client.register_bottle(
-        guest_ip, image_ref=image_ref, policy=inputs.policy,
-        metadata=inputs.metadata, tokens=tokens,
-    )
-    try:
-        provision_git_gate(gateway_name, reg.bottle_id, git_gate_plan)
-    except Exception:
-        client.teardown_bottle(reg.bottle_id)
-        raise
-
-    # Fetch the shared gateway CA here so the caller can install it in the
-    # rootfs (the same CA every agent on this host trusts for TLS interception).
-    gateway_ca_pem = DockerGateway(
-        name=gateway_name, network=GATEWAY_NETWORK,
-    ).ca_cert_pem()
-
-    return LaunchContext(
-        bottle_id=reg.bottle_id,
-        identity_token=reg.identity_token,
-        source_ip=guest_ip,
-        gateway_ca_pem=gateway_ca_pem,
-        orchestrator_url=url,
-    )
-
-
-def teardown_consolidated(
-    bottle_id: str, *, orchestrator_url: str, gateway_name: str = _FC_GATEWAY_NAME,
-) -> None:
-    """Deregister the bottle and remove its git-gate state from the gateway.
-    Both steps are idempotent so this is safe from a cleanup trap."""
-    OrchestratorClient(orchestrator_url).teardown_bottle(bottle_id)
-    deprovision_git_gate(gateway_name, bottle_id)
-
-
-__all__ = [
-    "LaunchContext",
-    "launch_consolidated",
-    "teardown_consolidated",
-    "ConsolidatedLaunchError",
-    "OrchestratorStartError",
-]

bot_bottle/backend/firecracker/launch.py

@@ -1,64 +1,75 @@
-"""Launch flow for the Firecracker backend (PRD 0070, consolidated).
+"""Launch flow for the Firecracker backend.
 
 Per bottle:
-  1. build the agent image (docker), export it to a cached ext4 rootfs;
-  2. ensure the per-host orchestrator + shared gateway are up;
-  3. claim a free TAP pool slot (rootless flock);
-  4. register the bottle on the orchestrator by the VM's guest IP (the
-     attribution key) and provision its git-gate state into the gateway;
-  5. boot the microVM on that TAP; wait for SSH;
-  6. provision (shared gateway CA, prompt, skills, workspace, git, supervise)
-     over SSH.
-
-The per-bottle Docker sidecar bundle is gone. The shared gateway handles
-egress / git-gate / supervise for every VM; Docker's PREROUTING DNAT routes
-the VMs' traffic to it, and the nft table's `ct status dnat accept` rule
-in the forward chain lets it pass. The VM still sends to `host_tap_ip:PORT`
-— the address its world is, by nft design, limited to.
+  1. mint the egress CA, build the agent image (docker), export it to a
+     cached ext4 rootfs;
+  2. claim a free TAP pool slot (rootless flock);
+  3. bring up the Docker sidecar bundle, publishing egress / git-gate /
+     supervise on the slot's host-side TAP IP at fixed ports;
+  4. boot the microVM on that TAP; wait for SSH;
+  5. provision (CA, prompt, skills, workspace, git, supervise) over SSH.
 
 Isolation is enforced by the operator-provisioned nft table (checked
-fail-closed in preflight): a VM reaches only the sidecar (DNAT'd from
-the host TAP IP) and nothing else.
+fail-closed in preflight): a VM reaches only its sidecar (DNAT'd from
+the host TAP IP) and nothing else. The agent's HTTPS_PROXY therefore
+points at `http://<host_tap_ip>:9099`, its only route to the world.
 """
 
 from __future__ import annotations
 
 import dataclasses
 import os
+import subprocess
 from contextlib import ExitStack, contextmanager
 from pathlib import Path
 from typing import Callable, Generator
 
-from ...agent_provider import runtime_for
 from ...bottle_state import (
     egress_state_dir,
     git_gate_state_dir,
     read_committed_image,
 )
 from ...egress import (
+    EGRESS_ROUTES_IN_CONTAINER,
     egress_agent_env_entries,
     egress_resolve_token_values,
+    egress_sidecar_env_entries,
 )
 from ...git_gate import (
     provision_git_gate_dynamic_keys,
     revoke_git_gate_provisioned_keys,
 )
-from ...log import info, warn
-from ...supervise import SUPERVISE_PORT
-from ..docker import util as docker_mod
-from ..docker.egress import EGRESS_PORT
+from ...log import die, info, warn
+from ...supervise import DB_PATH_IN_CONTAINER, SUPERVISE_PORT
+from ...util import expand_tilde
+from ..docker.egress import (
+    EGRESS_CA_IN_CONTAINER,
+    EGRESS_PORT,
+    egress_tls_init,
+)
+from ..docker.git_gate import (
+    GIT_GATE_ACCESS_HOOK_IN_CONTAINER,
+    GIT_GATE_CREDS_DIR_IN_CONTAINER,
+    GIT_GATE_ENTRYPOINT_IN_CONTAINER,
+    GIT_GATE_HOOK_IN_CONTAINER,
+)
+from ..docker.sidecar_bundle import (
+    SIDECAR_BUNDLE_DOCKERFILE,
+    SIDECAR_BUNDLE_IMAGE,
+)
 from ..util import AGENT_CA_BUNDLE, AGENT_CA_PATH
 from . import firecracker_vm, isolation_probe, netpool, util
 from .bottle import FirecrackerBottle
 from .bottle_plan import FirecrackerBottlePlan
-from .consolidated_launch import (
-    launch_consolidated,
-    teardown_consolidated,
-)
 
 
 _REPO_DIR = str(Path(__file__).resolve().parent.parent.parent.parent)
 _GIT_HTTP_PORT = 9420
+_GIT_GATE_READY_FILE = "/run/git-gate/ready"
+
+
+def sidecar_container_name(slug: str) -> str:
+    return f"bot-bottle-sidecars-{slug}"
 
 
 @contextmanager
@@ -67,8 +78,6 @@ def launch(
     *,
     provision: Callable[[FirecrackerBottlePlan, "FirecrackerBottle"], str | None],
 ) -> Generator[FirecrackerBottle, None, None]:
-    """Build, launch, and provision a Firecracker bottle via the consolidated
-    orchestrator. Teardown on exit."""
     stack = ExitStack()
     bottle_for_revoke = plan.manifest.bottle
     git_gate_dir_for_revoke = git_gate_state_dir(plan.slug)
@@ -85,75 +94,26 @@ def launch(
             raise teardown_exc
 
     try:
-        # Step 1: agent image. The sidecar bundle image is built by the
-        # orchestrator service (ensure_running → ensure_built); we only
-        # build the agent image here. Use a committed snapshot when available.
+        plan = _mint_certs(plan)
         plan = _build_agent_image(plan)
 
-        # Step 2: mint the git-gate dynamic (gitea) deploy keys, if any.
-        git_gate_plan = plan.git_gate_plan
-        if git_gate_plan.upstreams:
-            git_gate_plan = provision_git_gate_dynamic_keys(
-                plan.manifest.bottle, git_gate_plan, git_gate_state_dir(plan.slug),
-            )
-
-        # Step 3: claim a TAP slot; the flock is held until teardown.
+        # Claim a TAP slot; the flock is held until teardown closes it.
         slot, lock = netpool.allocate(plan.slug)
         stack.callback(lock.close)
         info(f"firecracker slot {slot.iface}: host={slot.host_ip} "
              f"guest={slot.guest_ip}")
 
-        # Step 4: register on the orchestrator + provision this bottle's
-        # git-gate state into the shared gateway. The per-bottle egress tokens
-        # are resolved from the host env now and handed to the orchestrator
-        # (in memory) for the gateway to inject — the agent never sees them.
-        # Attribution is by the VM's guest IP (unspoofable via /31 TAP + nft).
-        effective_env = {**os.environ, **plan.agent_provision.provisioned_env}
-        token_values = egress_resolve_token_values(
-            plan.egress_plan.token_env_map, effective_env,
-        )
-        ctx = launch_consolidated(
-            plan.egress_plan, git_gate_plan,
-            guest_ip=slot.guest_ip,
-            image_ref=plan.image,
-            tokens=token_values,
-        )
-        stack.callback(
-            teardown_consolidated, ctx.bottle_id,
-            orchestrator_url=ctx.orchestrator_url,
-        )
+        plan = _provision_git_gate_keys(plan)
 
-        # Step 5: install the SHARED gateway CA (replaces the per-bottle CA).
-        # Write it to a stable host path so the provisioner can copy it over SSH.
-        ca_dir = egress_state_dir(plan.slug) / "gateway-ca"
-        ca_dir.mkdir(parents=True, exist_ok=True)
-        ca_file = ca_dir / "gateway-ca.pem"
-        ca_file.write_text(ctx.gateway_ca_pem)
-        egress_plan = dataclasses.replace(
-            plan.egress_plan,
-            mitmproxy_ca_host_path=ca_file,
-            mitmproxy_ca_cert_only_host_path=ca_file,
-        )
-        # Point the agent's git-gate insteadOf rewrites and supervise MCP URL
-        # at the shared gateway (reached at the slot's host TAP IP — the VM
-        # sends there and Docker DNAT routes to the gateway container).
-        git_gate_url = (
-            f"http://{slot.host_ip}:{_GIT_HTTP_PORT}" if git_gate_plan.upstreams else ""
-        )
-        supervise_url = (
-            f"http://{slot.host_ip}:{SUPERVISE_PORT}/"
-            if plan.supervise_plan is not None else ""
-        )
-        plan = dataclasses.replace(
-            plan,
-            git_gate_plan=git_gate_plan,
-            egress_plan=egress_plan,
-            agent_proxy_url=f"http://{slot.host_ip}:{EGRESS_PORT}",
-            agent_git_gate_url=git_gate_url,
-            agent_supervise_url=supervise_url,
-        )
+        sidecar_name = sidecar_container_name(plan.slug)
+        _force_remove_container(sidecar_name)
+        _start_sidecar_bundle(plan, sidecar_name, slot.host_ip)
+        stack.callback(_force_remove_container, sidecar_name)
+        _stage_git_gate(plan, sidecar_name)
 
-        # Step 6: build the per-bottle rootfs + SSH key, then boot.
+        plan = _stamp_agent_urls(plan, slot.host_ip)
+
+        # Build the per-bottle rootfs + SSH key, then boot.
         base_dir = util.build_base_rootfs_dir(plan.image)
         run_dir = util.cache_dir() / "run" / plan.slug
         run_dir.mkdir(parents=True, exist_ok=True)
@@ -173,8 +133,8 @@ def launch(
         stack.callback(vm.terminate)
         firecracker_vm.wait_for_ssh(vm, private_key)
 
-        # Authoritative fail-closed egress-boundary check, before the agent
-        # runs: prove the VM cannot reach the host directly.
+        # Authoritative fail-closed egress-boundary check, before the
+        # agent runs: prove the VM cannot reach the host directly.
         isolation_probe.verify_isolation(private_key, slot.guest_ip)
 
         bottle = FirecrackerBottle(
@@ -199,21 +159,171 @@ def launch(
         teardown()
 
 
+def _mint_certs(plan: FirecrackerBottlePlan) -> FirecrackerBottlePlan:
+    egress_ca_host, egress_ca_cert_only = egress_tls_init(egress_state_dir(plan.slug))
+    egress_plan = dataclasses.replace(
+        plan.egress_plan,
+        mitmproxy_ca_host_path=egress_ca_host,
+        mitmproxy_ca_cert_only_host_path=egress_ca_cert_only,
+    )
+    return dataclasses.replace(plan, egress_plan=egress_plan)
+
+
 def _build_agent_image(plan: FirecrackerBottlePlan) -> FirecrackerBottlePlan:
+    _docker_build(SIDECAR_BUNDLE_IMAGE, _REPO_DIR, dockerfile=SIDECAR_BUNDLE_DOCKERFILE)
     committed = read_committed_image(plan.slug)
-    if committed and docker_mod.image_exists(committed):
+    if committed and _image_exists(committed):
         info(f"using committed image {committed!r}")
         return dataclasses.replace(
             plan,
             agent_provision=dataclasses.replace(plan.agent_provision, image=committed),
         )
-    docker_mod.build_image(plan.image, _REPO_DIR, dockerfile=plan.dockerfile_path)
-    docker_mod.verify_agent_image(
-        plan.image, runtime_for(plan.agent_provider_template).smoke_test,
-    )
+    _docker_build(plan.image, _REPO_DIR, dockerfile=plan.dockerfile_path)
     return plan
 
 
+def _provision_git_gate_keys(plan: FirecrackerBottlePlan) -> FirecrackerBottlePlan:
+    if not plan.git_gate_plan.upstreams:
+        return plan
+    git_gate_plan = provision_git_gate_dynamic_keys(
+        plan.manifest.bottle, plan.git_gate_plan, git_gate_state_dir(plan.slug),
+    )
+    return dataclasses.replace(plan, git_gate_plan=git_gate_plan)
+
+
+def _stamp_agent_urls(
+    plan: FirecrackerBottlePlan, host_ip: str,
+) -> FirecrackerBottlePlan:
+    proxy_url = f"http://{host_ip}:{EGRESS_PORT}"
+    supervise_url = (
+        f"http://{host_ip}:{SUPERVISE_PORT}/" if plan.supervise_plan is not None else ""
+    )
+    git_gate_url = (
+        f"http://{host_ip}:{_GIT_HTTP_PORT}" if plan.git_gate_plan.upstreams else ""
+    )
+    return dataclasses.replace(
+        plan,
+        agent_proxy_url=proxy_url,
+        agent_git_gate_url=git_gate_url,
+        agent_supervise_url=supervise_url,
+    )
+
+
+# --- sidecar bundle (Docker) ----------------------------------------
+
+def _start_sidecar_bundle(
+    plan: FirecrackerBottlePlan, sidecar_name: str, host_ip: str,
+) -> None:
+    argv = ["docker", "run", "--name", sidecar_name, "--detach", "--rm",
+            "-e", f"BOT_BOTTLE_SIDECAR_DAEMONS={','.join(_sidecar_daemons(plan))}"]
+    for entry in _sidecar_env_entries(plan):
+        argv += ["-e", entry]
+    for host_path, container_path, read_only in _sidecar_mounts(plan):
+        argv += ["-v", f"{host_path}:{container_path}{':ro' if read_only else ''}"]
+    # Publish on the slot's host TAP IP at fixed ports — each bottle
+    # has a distinct host_ip, so fixed ports never collide, and the VM
+    # reaches them at a stable, well-known address (its only route out).
+    for port in _sidecar_ports(plan):
+        argv += ["-p", f"{host_ip}:{port}:{port}"]
+    argv.append(SIDECAR_BUNDLE_IMAGE)
+
+    effective_env = {**dict(os.environ), **plan.agent_provision.provisioned_env}
+    token_values = egress_resolve_token_values(
+        plan.egress_plan.token_env_map, effective_env,
+    )
+    env = {**os.environ, **token_values}
+    info(f"docker run sidecar bundle {sidecar_name} (published on {host_ip})")
+    result = subprocess.run(argv, capture_output=True, text=True, env=env, check=False)
+    if result.returncode != 0:
+        die(f"docker run for sidecar bundle {sidecar_name} failed: "
+            f"{(result.stderr or '').strip() or '<no stderr>'}")
+
+
+def _sidecar_daemons(plan: FirecrackerBottlePlan) -> tuple[str, ...]:
+    daemons = ["egress"]
+    if plan.git_gate_plan.upstreams:
+        daemons += ["git-gate", "git-http"]
+    if plan.supervise_plan is not None:
+        daemons.append("supervise")
+    return tuple(daemons)
+
+
+def _sidecar_ports(plan: FirecrackerBottlePlan) -> tuple[int, ...]:
+    ports = [EGRESS_PORT]
+    if plan.git_gate_plan.upstreams:
+        ports.append(_GIT_HTTP_PORT)
+    if plan.supervise_plan is not None:
+        ports.append(SUPERVISE_PORT)
+    return tuple(ports)
+
+
+def _sidecar_env_entries(plan: FirecrackerBottlePlan) -> tuple[str, ...]:
+    env: list[str] = list(egress_sidecar_env_entries(plan.egress_plan))
+    if plan.git_gate_plan.upstreams:
+        env.append(f"BOT_BOTTLE_GIT_GATE_READY_FILE={_GIT_GATE_READY_FILE}")
+    if plan.supervise_plan is not None:
+        env += [
+            f"SUPERVISE_BOTTLE_SLUG={plan.slug}",
+            f"SUPERVISE_DB_PATH={DB_PATH_IN_CONTAINER}",
+            f"SUPERVISE_PORT={SUPERVISE_PORT}",
+        ]
+    return tuple(env)
+
+
+def _sidecar_mounts(
+    plan: FirecrackerBottlePlan,
+) -> tuple[tuple[str, str, bool], ...]:
+    mounts: list[tuple[str, str, bool]] = []
+    ep = plan.egress_plan
+    mounts.append((str(ep.mitmproxy_ca_host_path.parent),
+                   str(Path(EGRESS_CA_IN_CONTAINER).parent), False))
+    if ep.routes:
+        mounts.append((str(ep.routes_path.parent),
+                       str(Path(EGRESS_ROUTES_IN_CONTAINER).parent), True))
+    sp = plan.supervise_plan
+    if sp is not None:
+        mounts.append((str(sp.db_path.parent),
+                       str(Path(DB_PATH_IN_CONTAINER).parent), False))
+    return tuple(mounts)
+
+
+def _stage_git_gate(plan: FirecrackerBottlePlan, sidecar_name: str) -> None:
+    gp = plan.git_gate_plan
+    if not gp.upstreams:
+        return
+    _docker_exec(sidecar_name, [
+        "mkdir", "-p",
+        str(Path(GIT_GATE_HOOK_IN_CONTAINER).parent),
+        GIT_GATE_CREDS_DIR_IN_CONTAINER, "/git",
+        str(Path(_GIT_GATE_READY_FILE).parent),
+    ])
+    for host_path, container_path in _git_gate_files(plan):
+        _docker_cp(host_path, f"{sidecar_name}:{container_path}")
+    _docker_exec(sidecar_name, [
+        "sh", "-c",
+        f"chmod 755 {GIT_GATE_ENTRYPOINT_IN_CONTAINER} "
+        f"{GIT_GATE_HOOK_IN_CONTAINER} {GIT_GATE_ACCESS_HOOK_IN_CONTAINER} && "
+        f"chmod 600 {GIT_GATE_CREDS_DIR_IN_CONTAINER}/* && "
+        f"touch {_GIT_GATE_READY_FILE}",
+    ])
+
+
+def _git_gate_files(plan: FirecrackerBottlePlan) -> tuple[tuple[str, str], ...]:
+    gp = plan.git_gate_plan
+    files: list[tuple[str, str]] = [
+        (str(gp.entrypoint_script), GIT_GATE_ENTRYPOINT_IN_CONTAINER),
+        (str(gp.hook_script), GIT_GATE_HOOK_IN_CONTAINER),
+        (str(gp.access_hook_script), GIT_GATE_ACCESS_HOOK_IN_CONTAINER),
+    ]
+    for upstream in gp.upstreams:
+        files.append((expand_tilde(upstream.identity_file),
+                      f"{GIT_GATE_CREDS_DIR_IN_CONTAINER}/{upstream.name}-key"))
+        if upstream.known_hosts_file:
+            files.append((str(upstream.known_hosts_file),
+                          f"{GIT_GATE_CREDS_DIR_IN_CONTAINER}/{upstream.name}-known_hosts"))
+    return tuple(files)
+
+
 # --- agent guest env -------------------------------------------------
 
 def _agent_guest_env(plan: FirecrackerBottlePlan, host_ip: str) -> dict[str, str]:
@@ -245,3 +355,50 @@ def _agent_guest_env(plan: FirecrackerBottlePlan, host_ip: str) -> dict[str, str
         if value is not None:
             env[name] = value
     return env
+
+
+# --- docker helpers --------------------------------------------------
+
+def _docker_build(ref: str, context: str, *, dockerfile: str = "") -> None:
+    info(f"docker build {ref}")
+    args = ["docker", "build", "-t", ref]
+    if dockerfile:
+        if not os.path.isabs(dockerfile):
+            dockerfile = os.path.join(context, dockerfile)
+        args += ["-f", dockerfile]
+    args.append(context)
+    result = subprocess.run(args, check=False)
+    if result.returncode != 0:
+        die(f"docker build for {ref!r} failed")
+
+
+def _image_exists(ref: str) -> bool:
+    return subprocess.run(
+        ["docker", "image", "inspect", ref],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False,
+    ).returncode == 0
+
+
+def _force_remove_container(name: str) -> None:
+    subprocess.run(
+        ["docker", "rm", "-f", name],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False,
+    )
+
+
+def _docker_exec(name: str, argv: list[str]) -> None:
+    result = subprocess.run(
+        ["docker", "exec", name, *argv], capture_output=True, text=True, check=False,
+    )
+    if result.returncode != 0:
+        die(f"docker exec in {name} failed: "
+            f"{(result.stderr or '').strip() or '<no stderr>'}")
+
+
+def _docker_cp(host_path: str, dest: str) -> None:
+    result = subprocess.run(
+        ["docker", "cp", host_path, dest], capture_output=True, text=True, check=False,
+    )
+    if result.returncode != 0:
+        die(f"docker cp {host_path} -> {dest} failed: "
+            f"{(result.stderr or '').strip() or '<no stderr>'}")

bot_bottle/backend/macos_container/launch.py

@@ -17,7 +17,6 @@ from contextlib import ExitStack, contextmanager
 from pathlib import Path
 from typing import Callable, Generator
 
-from ...agent_provider import runtime_for
 from ...bottle_state import (
     egress_state_dir,
     git_gate_state_dir,
@@ -170,9 +169,6 @@ def _build_images(plan: MacosContainerBottlePlan) -> MacosContainerBottlePlan:
         _REPO_DIR,
         dockerfile=plan.dockerfile_path,
     )
-    container_mod.verify_agent_image(
-        plan.image, runtime_for(plan.agent_provider_template).smoke_test,
-    )
     return plan
 
 

bot_bottle/backend/macos_container/util.py

@@ -60,21 +60,13 @@ def dns_server() -> str:
 
 
 def build_image(ref: str, context: str, *, dockerfile: str = "") -> None:
-    """Build an OCI image with Apple's BuildKit-backed `container build`.
-
-    Set `BOT_BOTTLE_NO_CACHE=1` (the `start --no-cache` flag) to force
-    `--no-cache`. The npm/curl installers some provider Dockerfiles
-    shell out to can silently no-op on a transient network failure —
-    e.g. an `optionalDependencies` fetch for a platform-native binary —
-    and the builder will then cache that broken layer indefinitely."""
+    """Build an OCI image with Apple's BuildKit-backed `container build`."""
     info(
         f"building image {ref} from {context} with Apple Container "
         "(layer cache keeps repeat builds fast)"
     )
     _ensure_builder_dns()
     args = [_CONTAINER, "build", "-t", ref, "--dns", dns_server()]
-    if os.environ.get("BOT_BOTTLE_NO_CACHE") == "1":
-        args.append("--no-cache")
     if dockerfile:
         # `container build` resolves -f relative to the current working
         # directory, not the build context. Anchor a relative Dockerfile to
@@ -86,28 +78,6 @@ def build_image(ref: str, context: str, *, dockerfile: str = "") -> None:
     subprocess.run(args, check=True)
 
 
-def verify_agent_image(image: str, argv: tuple[str, ...]) -> None:
-    """Run `argv` inside a throwaway container of a freshly built agent
-    image and die loudly if it fails, instead of shipping an image
-    whose CLI only breaks at first real use. No-op when the provider
-    hasn't declared a smoke test (`AgentProviderRuntime.smoke_test`)."""
-    if not argv:
-        return
-    result = subprocess.run(
-        [_CONTAINER, "run", "--rm", "--entrypoint", argv[0], image, *argv[1:]],
-        capture_output=True,
-        text=True,
-        check=False,
-    )
-    if result.returncode != 0:
-        detail = (result.stderr or result.stdout or "").strip()
-        die(
-            f"agent image {image!r} failed its post-build smoke test "
-            f"({' '.join(argv)}): {detail}\n"
-            f"Try rebuilding from scratch: bot-bottle start --no-cache"
-        )
-
-
 def commit_container(container_name: str, image_tag: str) -> None:
     """Snapshot a running Apple Container as a local image.
 

bot_bottle/cli/start.py

@@ -46,17 +46,6 @@ def cmd_start(argv: list[str]) -> int:
     parser = argparse.ArgumentParser(prog=f"{PROG} start", add_help=True)
     parser.add_argument("--dry-run", action="store_true")
     parser.add_argument("--cwd", action="store_true", help="copy host cwd into the running bottle")
-    parser.add_argument(
-        "--no-cache",
-        action="store_true",
-        help=(
-            "rebuild agent/sidecar images from scratch, bypassing the "
-            "build layer cache. Use when an image looks broken after a "
-            "dependency bump — e.g. an installer's optionalDependencies "
-            "fetch silently no-op'd on a transient failure and got baked "
-            "into a cached layer."
-        ),
-    )
     parser.add_argument(
         "--backend",
         choices=known_backend_names(),
@@ -108,11 +97,6 @@ def cmd_start(argv: list[str]) -> int:
     args = parser.parse_args(argv)
 
     dry_run = args.dry_run or os.environ.get("BOT_BOTTLE_DRY_RUN") == "1"
-    if args.no_cache or os.environ.get("BOT_BOTTLE_NO_CACHE") == "1":
-        # Read by build_image() in each backend's util module — set here
-        # so both the interactive and --headless paths pick it up without
-        # threading a no_cache field through every backend's plan dataclass.
-        os.environ["BOT_BOTTLE_NO_CACHE"] = "1"
 
     manifest = ManifestIndex.resolve(USER_CWD)
     backend_name: str | None = args.backend

bot_bottle/contrib/claude/agent_provider.py

@@ -91,7 +91,6 @@ _RUNTIME = AgentProviderRuntime(
     prompt_mode="append_file",
     bypass_args=("--dangerously-skip-permissions",),
     resume_args=("--continue",),
-    smoke_test=("claude", "--version"),
 )
 
 

bot_bottle/contrib/codex/agent_provider.py

@@ -61,7 +61,6 @@ _RUNTIME = AgentProviderRuntime(
     prompt_mode="read_prompt_file",
     bypass_args=("--dangerously-bypass-approvals-and-sandbox",),
     resume_args=("resume", "--last"),
-    smoke_test=(_CODEX_CLI, "--version"),
 )
 
 

bot_bottle/egress_addon.py

@@ -10,7 +10,6 @@ import json
 import os
 import signal
 import sys
-import typing
 from pathlib import Path
 
 from mitmproxy import http  # type: ignore[import-not-found]  # pylint: disable=import-error
@@ -231,27 +230,21 @@ class EgressAddon:
             + "\n"
         )
 
-    def _resolve_flow(
-        self, flow: http.HTTPFlow,
-    ) -> "tuple[Config, str, typing.Mapping[str, str]]":
-        """The `(Config, supervise slug, env)` to apply to this request.
-        Single-tenant → the static `self.config`, the env slug, and the process
-        env. Consolidated → the calling bottle's Config + bottle id + auth
-        tokens, resolved by source IP in one round-trip (fail-closed to deny-all
-        + empty slug if unattributed); `env` is the process env overlaid with
-        the bottle's tokens, so upstream-auth injection (and DLP) use *this*
-        bottle's credentials — exactly what the per-bottle sidecar's env did.
-        The identity token, if the agent injected one, is read then stripped so
-        it never leaks upstream."""
+    def _resolve_flow(self, flow: http.HTTPFlow) -> "tuple[Config, str]":
+        """The `(Config, supervise slug)` to apply to this request. Single-tenant
+        → the static `self.config` and the env slug. Consolidated → the calling
+        bottle's Config and its bottle id, resolved by source IP in one
+        round-trip (fail-closed to deny-all + empty slug if unattributed). The
+        identity token, if the agent injected one, is read then stripped so it
+        never leaks upstream. The slug keys both the proposal queue and the
+        per-bottle safelist, so an approval only ever affects its own bottle."""
         if self._resolver is None:
-            return self.config, self._supervise_slug, os.environ
+            return self.config, self._supervise_slug
         conn = flow.client_conn
         client_ip = conn.peername[0] if conn and conn.peername else ""
         token = flow.request.headers.get(IDENTITY_HEADER, "")
         flow.request.headers.pop(IDENTITY_HEADER, None)
-        config, slug, tokens = resolve_client_context(self._resolver, client_ip, token)
-        env = {**os.environ, **tokens} if tokens else os.environ
-        return config, slug, env
+        return resolve_client_context(self._resolver, client_ip, token)
 
     async def request(self, flow: http.HTTPFlow) -> None:
         request_path, _, query = flow.request.path.partition("?")
@@ -260,14 +253,14 @@ class EgressAddon:
             self._serve_introspection(flow, request_path)
             return
 
-        config, slug, env = self._resolve_flow(flow)
+        config, slug = self._resolve_flow(flow)
 
         # DLP outbound scan BEFORE stripping auth — catches tokens the
         # agent tried to smuggle in any header, path, query param, or body.
         # Hostname is included to catch DNS-tunnelling exfiltration attempts.
         route = match_route(config.routes, flow.request.pretty_host)
         if route is not None:
-            if not await self._handle_outbound_dlp(flow, route, slug, env):
+            if not await self._handle_outbound_dlp(flow, route, slug):
                 return
             # The redact policy may have rewritten the request line; recompute
             # the path/query the git checks below rely on.
@@ -306,7 +299,7 @@ class EgressAddon:
             config.routes,
             flow.request.pretty_host,
             request_path,
-            env,
+            os.environ,
             request_method=flow.request.method,
             request_headers=req_headers,
         )
@@ -332,12 +325,10 @@ class EgressAddon:
         flow: http.HTTPFlow,
         route: Route,
         slug: str,
-        env: "typing.Mapping[str, str]",
     ) -> bool:
         """Scan the outbound request and apply the route's on-match policy
-        (PRD 0062). `env` is the per-bottle env overlay (process env + this
-        bottle's tokens) used for DLP detection. Returns True if the request may
-        be forwarded, False if a 403 response has been written to `flow`.
+        (PRD 0062). Returns True if the request may be forwarded, False if a
+        403 response has been written to `flow`.
 
         Loops so the supervise policy can re-scan after each approval — a
         second, un-approved token in the same request is still caught."""
@@ -354,7 +345,7 @@ class EgressAddon:
                 flow.request.pretty_host, request_path, query, headers, "",
             )
             result = scan_outbound(
-                route, scan_text, env,
+                route, scan_text, os.environ,
                 safe_tokens=self._safe_tokens_for(slug), crlf_text=crlf_text,
             )
             if result is None or result.severity != "block":
@@ -365,7 +356,7 @@ class EgressAddon:
             # redact scrubs every detection (tokens and structural CRLF) and
             # forwards; it fails closed only if a match survives the scrub.
             if policy == ON_MATCH_REDACT:
-                if self._redact_outbound(flow, route, env):
+                if self._redact_outbound(flow, route):
                     if self.config.log >= LOG_BLOCKS:
                         sys.stderr.write(json.dumps({
                             "event": "egress_redacted",
@@ -393,31 +384,29 @@ class EgressAddon:
             if not self._supervise_available(slug):
                 self._block_dlp(flow, result)
                 return False
-            approved = await self._supervise_token_block(flow, request_path, result, slug, env)
+            approved = await self._supervise_token_block(flow, request_path, result, slug)
             if not approved:
                 return False  # _supervise_token_block wrote the 403 response
             # loop: the approved value is now in safe_tokens; re-scan.
 
-    def _redact_outbound(
-        self, flow: http.HTTPFlow, route: Route, env: "typing.Mapping[str, str]",
-    ) -> bool:
+    def _redact_outbound(self, flow: http.HTTPFlow, route: Route) -> bool:
         """Scrub detected tokens (and CRLF injection sequences) from the mutable
-        request surfaces (body, headers, path/query) and re-scan. `env` is the
-        per-bottle env overlay. Returns True if the request is now clean; False
-        if a block-severity match remains on a surface redaction cannot rewrite
-        (the hostname) so the caller fails closed."""
+        request surfaces (body, headers, path/query) and re-scan. Returns True
+        if the request is now clean; False if a block-severity match remains on
+        a surface redaction cannot rewrite (the hostname) so the caller fails
+        closed."""
         body = flow.request.get_text(strict=False)
         if body:
-            redacted_body = redact_tokens(body, env=env)
+            redacted_body = redact_tokens(body, env=os.environ)
             if redacted_body != body:
                 flow.request.text = redacted_body
         for name, value in list(flow.request.headers.items()):
             if name.lower() == "host":
                 continue  # routing-critical; never a legitimate token
-            redacted = strip_crlf(redact_tokens(value, env=env))
+            redacted = strip_crlf(redact_tokens(value, env=os.environ))
             if redacted != value:
                 flow.request.headers[name] = redacted
-        redacted_path = strip_crlf(redact_tokens(flow.request.path, env=env))
+        redacted_path = strip_crlf(redact_tokens(flow.request.path, env=os.environ))
         if redacted_path != flow.request.path:
             flow.request.path = redacted_path
 
@@ -430,7 +419,7 @@ class EgressAddon:
         crlf_text = build_outbound_scan_text(
             flow.request.pretty_host, request_path, query, headers, "",
         )
-        result = scan_outbound(route, scan_text, env, crlf_text=crlf_text)
+        result = scan_outbound(route, scan_text, os.environ, crlf_text=crlf_text)
         return result is None or result.severity != "block"
 
     async def _supervise_token_block(
@@ -439,22 +428,20 @@ class EgressAddon:
         request_path: str,
         result: ScanResult,
         slug: str,
-        env: "typing.Mapping[str, str]",
     ) -> bool:
         """Route a token DLP block to the operator's supervisor queue and wait.
 
         `slug` attributes the proposal to the calling bottle (its own queue +
         safelist) — in the shared gateway this is what keeps one bottle's
-        approval from unblocking another's request. `env` is the per-bottle env
-        overlay used to redact secrets from the proposal text. Returns True if
-        the operator approved (the matched value is added to that bottle's
-        safelist and the caller re-scans); False if the request must be blocked
-        (a 403 response has been written to `flow`)."""
+        approval from unblocking another's request. Returns True if the operator
+        approved (the matched value is added to that bottle's safelist and the
+        caller re-scans); False if the request must be blocked (a 403 response
+        has been written to `flow`)."""
         host = flow.request.pretty_host
         payload = build_token_allow_payload(
-            redact_tokens(host, env=env),
+            redact_tokens(host, env=os.environ),
             flow.request.method,
-            redact_tokens(request_path, env=env),
+            redact_tokens(request_path, env=os.environ),
             result,
         )
         proposal = _sv.Proposal.new(

bot_bottle/egress_addon_core.py

@@ -450,31 +450,28 @@ def resolve_client_config(
 
 class ContextResolverLike(typing.Protocol):
     """The bit of `policy_resolver.PolicyResolver` `resolve_client_context`
-    needs — one round-trip returning policy, bottle id, and auth tokens."""
+    needs — one round-trip returning both policy and bottle id."""
 
     def resolve_policy_and_bottle_id(
         self, source_ip: str, identity_token: str = ...,
-    ) -> "tuple[str | None, str | None, dict[str, str]]":
+    ) -> "tuple[str | None, str | None]":
         ...
 
 
 def resolve_client_context(
     resolver: ContextResolverLike, client_ip: str, identity_token: str = "",
-) -> "tuple[Config, str, dict[str, str]]":
-    """The calling client's `(Config, bottle_id, tokens)` in one round-trip —
+) -> "tuple[Config, str]":
+    """The calling client's `(Config, bottle_id)` in one round-trip —
     **fail-closed**. The Config follows `resolve_client_config`'s deny-all
     rules; the bottle id is `""` whenever unattributed or the orchestrator
-    errored (caller treats as "supervise unavailable", never another bottle's
-    queue); `tokens` are the per-bottle upstream auth values the addon injects.
-    One `/resolve` keys the egress policy, the supervise queue + safelist, and
-    auth injection."""
+    errored, which the caller treats as "supervise unavailable for this
+    bottle" (never another bottle's queue). One `/resolve` keys both the
+    per-request egress policy and the per-bottle supervise queue + safelist."""
     try:
-        policy, bottle_id, tokens = resolver.resolve_policy_and_bottle_id(
-            client_ip, identity_token,
-        )
+        policy, bottle_id = resolver.resolve_policy_and_bottle_id(client_ip, identity_token)
     except Exception:  # noqa: BLE001  # pylint: disable=broad-exception-caught
-        return Config(routes=()), "", {}  # orchestrator unreachable/errored → deny
-    return _config_from_policy(policy), (bottle_id or ""), tokens
+        return Config(routes=()), ""  # orchestrator unreachable/errored → deny
+    return _config_from_policy(policy), (bottle_id or "")
 
 
 # ---------------------------------------------------------------------------

bot_bottle/git_gate.py

@@ -46,7 +46,6 @@ from .git_gate_render import (
     git_gate_known_hosts_line,
     git_gate_render_access_hook,
     git_gate_render_entrypoint,
-    git_gate_render_provision,
     git_gate_render_gitconfig,
     git_gate_render_hook,
     git_gate_upstreams_for_bottle,
@@ -156,7 +155,6 @@ __all__ = [
     "git_gate_render_gitconfig",
     "git_gate_known_hosts_line",
     "git_gate_render_entrypoint",
-    "git_gate_render_provision",
     "git_gate_render_hook",
     "git_gate_render_access_hook",
     "provision_git_gate_dynamic_keys",

bot_bottle/git_gate_render.py

@@ -9,7 +9,6 @@ own; `git_gate` re-exports these names for API stability."""
 
 from __future__ import annotations
 
-import re
 import shlex
 from dataclasses import dataclass
 from pathlib import Path
@@ -126,18 +125,22 @@ def git_gate_known_hosts_line(host: str, port: str, key: str) -> str:
     return f"{target} {key}\n"
 
 
-def _git_gate_init_repo_fn(repo_root: str, creds_dir: str) -> list[str]:
-    """The `init_repo` shell function, parameterized by the bare-repo root
-    and the per-bottle creds dir. Single source of the credential-wiring
-    logic, shared by the single-tenant daemon entrypoint (`/git`,
-    `/git-gate/creds`) and the consolidated per-bottle provisioning
-    (`/git/<bottle_id>`, `/git-gate/creds/<bottle_id>`)."""
-    return [
+def git_gate_render_entrypoint(upstreams: tuple[GitGateUpstream, ...]) -> str:
+    """Posix-sh entrypoint. One `init_repo` call per upstream, then
+    `exec git daemon`. The function reads
+    `/git-gate/creds/<name>-{key,known_hosts}` (bind-mounted into
+    the bundle by the renderer) and wires them into each bare repo's
+    config; the access-hook + pre-receive hook pick those paths up
+    at fetch / push time."""
+    lines = [
+        "#!/bin/sh",
+        "set -eu",
+        "",
         "init_repo() {",
         "  name=$1",
         "  upstream_url=$2",
-        f"  keyfile={creds_dir}/${{name}}-key",
-        f"  hostsfile={creds_dir}/${{name}}-known_hosts",
+        "  keyfile=/git-gate/creds/${name}-key",
+        "  hostsfile=/git-gate/creds/${name}-known_hosts",
         "",
         # `|| true`: PRD 0018 chunk 3+ bind-mounts these RO from the
         # host, so chmod-syscalls fail with EROFS. The files already
@@ -150,14 +153,14 @@ def _git_gate_init_repo_fn(repo_root: str, creds_dir: str) -> list[str]:
         "    chmod 600 \"$hostsfile\" 2>/dev/null || true",
         "  fi",
         "",
-        f"  repo={repo_root}/${{name}}.git",
+        "  repo=/git/${name}.git",
         "  if [ ! -d \"$repo\" ]; then",
         "    git init --bare \"$repo\" >/dev/null",
-        # --mirror=fetch sets remote.origin.fetch = +refs/*:refs/* so a later
-        # `git fetch origin` mirrors the upstream's full ref graph (heads,
-        # tags, notes) into the bare repo at canonical paths. It does NOT set
-        # remote.origin.mirror=true, so an explicit `git push origin
-        # <ref>:<ref>` still pushes one ref.
+        # --mirror=fetch sets remote.origin.fetch = +refs/*:refs/* so",
+        # a later `git fetch origin` mirrors the upstream's full ref",
+        # graph (heads, tags, notes) into the bare repo at canonical",
+        # paths. It does NOT set remote.origin.mirror=true, so an",
+        # explicit `git push origin <ref>:<ref>` still pushes one ref.",
         "    git -C \"$repo\" remote add --mirror=fetch origin \"$upstream_url\"",
         "  fi",
         "  git -C \"$repo\" config git-gate.identityFile \"$keyfile\"",
@@ -167,19 +170,9 @@ def _git_gate_init_repo_fn(repo_root: str, creds_dir: str) -> list[str]:
         "  git -C \"$repo\" config http.receivepack true",
         "  install -m 755 /etc/git-gate/pre-receive \"$repo/hooks/pre-receive\"",
         "}",
+        "",
+        "mkdir -p /git",
     ]
-
-
-def git_gate_render_entrypoint(upstreams: tuple[GitGateUpstream, ...]) -> str:
-    """Posix-sh entrypoint. One `init_repo` call per upstream, then
-    `exec git daemon`. The function reads
-    `/git-gate/creds/<name>-{key,known_hosts}` (bind-mounted into
-    the bundle by the renderer) and wires them into each bare repo's
-    config; the access-hook + pre-receive hook pick those paths up
-    at fetch / push time."""
-    lines = ["#!/bin/sh", "set -eu", ""]
-    lines += _git_gate_init_repo_fn("/git", "/git-gate/creds")
-    lines += ["", "mkdir -p /git"]
     for u in upstreams:
         lines.append(f"init_repo {shlex.quote(u.name)} {shlex.quote(u.upstream_url)}")
     lines.extend([
@@ -197,35 +190,6 @@ def git_gate_render_entrypoint(upstreams: tuple[GitGateUpstream, ...]) -> str:
     return "\n".join(lines) + "\n"
 
 
-# A bottle id namespaces the consolidated gateway's repo + creds dirs; it is
-# embedded unquoted in the provisioning script, so restrict it to a shell- and
-# path-safe alphabet (registry ids are token_hex — this is defense in depth).
-_SAFE_BOTTLE_ID = re.compile(r"[A-Za-z0-9_-]+")
-
-
-def git_gate_render_provision(
-    bottle_id: str, upstreams: tuple[GitGateUpstream, ...],
-) -> str:
-    """Posix-sh script that provisions ONE bottle's bare repos into the
-    consolidated gateway (PRD 0070), under `/git/<bottle_id>/` with creds
-    read from `/git-gate/creds/<bottle_id>/`. Init-only — no `git daemon`,
-    since the shared gateway already serves every bottle; run inside the
-    running gateway when the bottle is registered.
-
-    Isolating each bottle's repo root and creds dir by id is what keeps one
-    bottle's push credentials out of another's repos on the shared gateway."""
-    if not _SAFE_BOTTLE_ID.fullmatch(bottle_id):
-        raise ValueError(f"git-gate: unsafe bottle id {bottle_id!r}")
-    repo_root = f"/git/{bottle_id}"
-    creds_dir = f"/git-gate/creds/{bottle_id}"
-    lines = ["#!/bin/sh", "set -eu", ""]
-    lines += _git_gate_init_repo_fn(repo_root, creds_dir)
-    lines += ["", f"mkdir -p {shlex.quote(repo_root)}"]
-    for u in upstreams:
-        lines.append(f"init_repo {shlex.quote(u.name)} {shlex.quote(u.upstream_url)}")
-    return "\n".join(lines) + "\n"
-
-
 def git_gate_render_hook() -> str:
     """The shared pre-receive hook: gitleaks-scan all incoming refs,
     then forward each accepted ref to the real upstream (`origin`)

bot_bottle/git_http_backend.py

@@ -188,14 +188,6 @@ class GitHttpHandler(BaseHTTPRequestHandler):
             "SERVER_PORT": str(self.server.server_port),  # type: ignore
             "SERVER_PROTOCOL": self.request_version,
         })
-        # Consolidated mode: attribute the gitleaks-allow supervise proposal
-        # (written by receive-pack's pre-receive hook, a child of the CGI we
-        # spawn below) to the calling bottle. The namespaced root is
-        # `<base>/<bottle_id>`, so its final component is the bottle id — the
-        # same per-bottle key egress uses. Single-tenant leaves the hook's
-        # container-stamped SUPERVISE_BOTTLE_SLUG untouched.
-        if getattr(self.server, "policy_resolver", None) is not None:
-            env["SUPERVISE_BOTTLE_SLUG"] = sandbox_root.name
         for header, variable in (
             ("accept", "HTTP_ACCEPT"),
             ("content-encoding", "HTTP_CONTENT_ENCODING"),

bot_bottle/orchestrator/__main__.py

@@ -51,13 +51,7 @@ def main(argv: list[str] | None = None) -> int:
     # anything; 'docker' runs real containers (firecracker drops in later).
     secret = secrets.token_bytes(32)
     broker: LaunchBroker = DockerBroker(secret) if args.broker == "docker" else StubBroker(secret)
-    # Standalone `--gateway` (not the consolidated flow, where the host
-    # lifecycle runs the gateway). The gateway resolves against this same
-    # process; the URL is only reachable when they share a docker network.
-    gateway: Gateway | None = (
-        DockerGateway(orchestrator_url=f"http://{args.host}:{args.port}")
-        if args.gateway else None
-    )
+    gateway: Gateway | None = DockerGateway() if args.gateway else None
     orchestrator = Orchestrator(registry, broker, secret, gateway)
 
     # One persistent per-host gateway, shared by every bottle: build the

bot_bottle/orchestrator/client.py

@@ -1,144 +0,0 @@
-"""Host-side control-plane client (PRD 0070).
-
-The launch path talks to the orchestrator over its HTTP control plane to
-register, re-policy, and tear down bottles — the counterpart to the
-gateway-side `PolicyResolver` (which only reads `/resolve`). Where
-`PolicyResolver` is fail-closed and lives in the untrusted data plane, this
-is the trusted control-plane caller: a non-success response is an error the
-launch path must surface, not silently swallow.
-
-Stdlib-only, so the CLI can drive the orchestrator without any dependency.
-"""
-
-from __future__ import annotations
-
-import json
-import urllib.error
-import urllib.request
-from dataclasses import dataclass
-
-DEFAULT_TIMEOUT_SECONDS = 5.0
-
-
-class OrchestratorClientError(RuntimeError):
-    """A control-plane call failed (unreachable, or an unexpected status)."""
-
-
-@dataclass(frozen=True)
-class RegisteredBottle:
-    """What `POST /bottles` returns: the minted bottle id and the per-bottle
-    identity token the agent presents for app-layer attribution."""
-
-    bottle_id: str
-    identity_token: str
-
-
-class OrchestratorClient:
-    """Trusted host-side client for the orchestrator control plane."""
-
-    def __init__(self, base_url: str, *, timeout: float = DEFAULT_TIMEOUT_SECONDS) -> None:
-        self._base = base_url.rstrip("/")
-        self._timeout = timeout
-
-    def _request(
-        self, method: str, path: str, body: dict[str, object] | None = None,
-    ) -> tuple[int, dict[str, object]]:
-        """Send one request; return `(status, payload)`. Raises
-        `OrchestratorClientError` only when the orchestrator can't be reached
-        or returns malformed data — HTTP *status* codes are returned so
-        callers can treat 404 as a meaningful "no such bottle"."""
-        data = json.dumps(body).encode() if body is not None else None
-        headers = {"Content-Type": "application/json"} if data is not None else {}
-        req = urllib.request.Request(
-            f"{self._base}{path}", data=data, method=method, headers=headers,
-        )
-        try:
-            with urllib.request.urlopen(req, timeout=self._timeout) as resp:
-                raw = resp.read()
-                payload = json.loads(raw) if raw else {}
-                return resp.status, payload if isinstance(payload, dict) else {}
-        except urllib.error.HTTPError as e:
-            # A structured error response still carries a usable status.
-            try:
-                payload = json.loads(e.read() or b"{}")
-            except (ValueError, OSError):
-                payload = {}
-            return e.code, payload if isinstance(payload, dict) else {}
-        except (urllib.error.URLError, TimeoutError, OSError, ValueError) as e:
-            raise OrchestratorClientError(f"{method} {path}: {e}") from e
-
-    def _ok(self, method: str, path: str, body: dict[str, object] | None = None) -> dict[str, object]:
-        """`_request` that requires a 2xx, raising otherwise."""
-        status, payload = self._request(method, path, body)
-        if not 200 <= status < 300:
-            detail = payload.get("error", "")
-            raise OrchestratorClientError(f"{method} {path}: HTTP {status} {detail}".rstrip())
-        return payload
-
-    def health(self) -> bool:
-        """True iff the control plane answers `GET /health` with 200."""
-        try:
-            status, _ = self._request("GET", "/health")
-        except OrchestratorClientError:
-            return False
-        return status == 200
-
-    def register_bottle(
-        self,
-        source_ip: str,
-        *,
-        image_ref: str = "",
-        metadata: str = "",
-        policy: str = "",
-        tokens: dict[str, str] | None = None,
-    ) -> RegisteredBottle:
-        """Register a bottle and broker its launch (`POST /bottles`). `tokens`
-        are the per-bottle egress auth values (env_name -> value) the
-        orchestrator holds in memory for the gateway to inject. Returns the
-        minted id + identity token."""
-        payload = self._ok("POST", "/bottles", {
-            "source_ip": source_ip,
-            "image_ref": image_ref,
-            "metadata": metadata,
-            "policy": policy,
-            "tokens": tokens or {},
-        })
-        bottle_id = payload.get("bottle_id")
-        token = payload.get("identity_token")
-        if not isinstance(bottle_id, str) or not isinstance(token, str):
-            raise OrchestratorClientError("register: response missing bottle_id/identity_token")
-        return RegisteredBottle(bottle_id=bottle_id, identity_token=token)
-
-    def teardown_bottle(self, bottle_id: str) -> bool:
-        """Tear a bottle down (`DELETE /bottles/<id>`). False if the
-        orchestrator didn't know it (404) — idempotent for cleanup paths."""
-        status, _ = self._request("DELETE", f"/bottles/{bottle_id}")
-        if status == 404:
-            return False
-        if not 200 <= status < 300:
-            raise OrchestratorClientError(f"teardown {bottle_id}: HTTP {status}")
-        return True
-
-    def set_policy(self, bottle_id: str, policy: str) -> bool:
-        """Live-reload a bottle's policy (`PUT /bottles/<id>/policy`). False on
-        404 (unknown bottle)."""
-        status, _ = self._request("PUT", f"/bottles/{bottle_id}/policy", {"policy": policy})
-        if status == 404:
-            return False
-        if not 200 <= status < 300:
-            raise OrchestratorClientError(f"set_policy {bottle_id}: HTTP {status}")
-        return True
-
-    def list_bottles(self) -> list[dict[str, object]]:
-        """Every registered bottle's redacted record (`GET /bottles`)."""
-        payload = self._ok("GET", "/bottles")
-        bottles = payload.get("bottles")
-        return bottles if isinstance(bottles, list) else []
-
-
-__all__ = [
-    "OrchestratorClient",
-    "OrchestratorClientError",
-    "RegisteredBottle",
-    "DEFAULT_TIMEOUT_SECONDS",
-]

bot_bottle/orchestrator/control_plane.py

@@ -34,7 +34,6 @@ import http.server
 import json
 import os
 import socketserver
-import sys
 import typing
 from urllib.parse import urlsplit
 
@@ -81,16 +80,11 @@ def dispatch(  # pylint: disable=too-many-return-statements,too-many-branches
         image_ref = data.get("image_ref")
         metadata = data.get("metadata")
         policy = data.get("policy")
-        raw_tokens = data.get("tokens")
-        tokens = {
-            k: v for k, v in raw_tokens.items() if isinstance(k, str) and isinstance(v, str)
-        } if isinstance(raw_tokens, dict) else {}
         rec = orch.launch_bottle(
             source_ip,
             image_ref=image_ref if isinstance(image_ref, str) else "",
             metadata=metadata if isinstance(metadata, str) else "",
             policy=policy if isinstance(policy, str) else "",
-            tokens=tokens,
         )
         return 201, {"bottle_id": rec.bottle_id, "identity_token": rec.identity_token}
 
@@ -142,13 +136,7 @@ def dispatch(  # pylint: disable=too-many-return-statements,too-many-branches
         rec = orch.resolve(source_ip, token if isinstance(token, str) else "")
         if rec is None:
             return 403, {"error": "unattributed"}
-        # tokens are the in-memory per-bottle egress auth values the gateway
-        # injects; served here, never persisted.
-        return 200, {
-            "bottle_id": rec.bottle_id,
-            "policy": rec.policy,
-            "tokens": orch.tokens_for(rec.bottle_id),
-        }
+        return 200, {"bottle_id": rec.bottle_id, "policy": rec.policy}
 
     return 404, {"error": "not found"}
 
@@ -163,20 +151,12 @@ class Handler(http.server.BaseHTTPRequestHandler):
             super().log_message(format, *args)
 
     def _serve(self, method: str) -> None:
-        """Read the request body, dispatch it, and write the JSON reply. A
-        dispatch failure (e.g. a broker error) returns a 500 rather than
-        crashing the connection, so one bad request can't take the control
-        plane down for the caller."""
+        """Read the request body, dispatch it, and write the JSON reply."""
         server = self.server
         assert isinstance(server, ControlPlaneServer)
         length = int(self.headers.get("Content-Length") or 0)
         body = self.rfile.read(length) if length > 0 else b""
-        try:
-            status, payload = dispatch(server.orchestrator, method, self.path, body)
-        except Exception as e:  # noqa: BLE001 — the control plane must stay up
-            sys.stderr.write(f"orchestrator: {method} {self.path} failed: {e!r}\n")
-            sys.stderr.flush()
-            status, payload = 500, {"error": f"internal error: {e}"}
+        status, payload = dispatch(server.orchestrator, method, self.path, body)
         data = json.dumps(payload).encode()
         self.send_response(status)
         self.send_header("Content-Type", "application/json")

bot_bottle/orchestrator/gateway.py

@@ -19,31 +19,12 @@ from __future__ import annotations
 
 import abc
 import os
-import time
 from pathlib import Path
 
 from ..docker_cmd import run_docker
 
-# The gateway's mitmproxy writes its CA a beat after the container starts, so
-# reads poll for it rather than assuming it's there on a fresh launch.
-_CA_POLL_SECONDS = 0.5
-DEFAULT_CA_TIMEOUT_SECONDS = 30.0
-
 GATEWAY_NAME = "bot-bottle-orch-gateway"
 GATEWAY_LABEL = "bot-bottle-orch-gateway=1"
-# The single user-defined network the gateway and every agent bottle share.
-# Agents attach here with a pinned IP and reach the gateway's egress /
-# git-http / supervise ports by its address — no host port publishing, and
-# the source IP the gateway attributes by is the address on this network.
-GATEWAY_NETWORK = "bot-bottle-gateway"
-
-# mitmproxy's CA dir in the bundle. A persistent named volume here keeps the
-# gateway's self-generated CA STABLE across container recreation — every agent
-# installs this one CA to trust the shared gateway's TLS interception, so it
-# must not rotate when the gateway restarts.
-MITMPROXY_HOME = "/home/mitmproxy/.mitmproxy"
-GATEWAY_CA_VOLUME = "bot-bottle-gateway-mitmproxy"
-GATEWAY_CA_CERT = f"{MITMPROXY_HOME}/mitmproxy-ca-cert.pem"
 
 # The real sidecar-bundle image + its Dockerfile. Kept as a local constant
 # rather than imported from backend.docker.sidecar_bundle, which would drag
@@ -96,47 +77,29 @@ class DockerGateway(Gateway):
         image_ref: str = GATEWAY_IMAGE,
         *,
         name: str = GATEWAY_NAME,
-        network: str = GATEWAY_NETWORK,
-        orchestrator_url: str = "",
         build_context: Path | None = None,
         dockerfile: str | None = GATEWAY_DOCKERFILE,
-        host_port_bindings: tuple[int, ...] = (),
     ) -> None:
         self.image_ref = image_ref
         self.name = name
-        self.network = network
-        # The control-plane URL the gateway's data plane resolves per bottle
-        # against — reached by container name over docker DNS on the shared
-        # network (container↔container, no host firewall). Empty → single-tenant.
-        self._orchestrator_url = orchestrator_url
         self._build_context = build_context or _REPO_ROOT
         self._dockerfile = dockerfile
-        # Ports published on the host (0.0.0.0). Used by the Firecracker
-        # backend's dev-harness gateway so VMs can reach it via their TAP link;
-        # Docker's DNAT + the nft `ct status dnat accept` rule handle the rest.
-        self._host_port_bindings = host_port_bindings
 
     def image_exists(self) -> bool:
         return run_docker(["docker", "image", "inspect", self.image_ref]).returncode == 0
 
     def ensure_built(self) -> None:
-        """Build the bundle image from its Dockerfile, **cache-aware** — cheap
-        (a cache check) when nothing changed, a real rebuild when the flat
-        sources (egress addon / git-http / policy_resolver / supervise) moved.
-
-        This deliberately builds every time rather than build-if-missing: the
-        per-bottle model kept the image fresh via compose's `build:` on up, and
-        a stale image silently runs the OLD single-tenant daemons. No-op only
-        when no dockerfile is configured (a pre-pulled image). BOT_BOTTLE_NO_CACHE
-        forces a full rebuild (parity with `start --no-cache`)."""
-        if self._dockerfile is None:
+        """Build the bundle image from its Dockerfile when it's missing.
+        No-op when the image is already present, or when no dockerfile is
+        configured (e.g. a pre-pulled image)."""
+        if self._dockerfile is None or self.image_exists():
             return
-        argv = ["docker", "build", "-t", self.image_ref,
-                "-f", str(self._build_context / self._dockerfile),
-                str(self._build_context)]
-        if os.environ.get("BOT_BOTTLE_NO_CACHE"):
-            argv.insert(2, "--no-cache")
-        proc = run_docker(argv)
+        proc = run_docker([
+            "docker", "build",
+            "-t", self.image_ref,
+            "-f", str(self._build_context / self._dockerfile),
+            str(self._build_context),
+        ])
         if proc.returncode != 0:
             raise GatewayError(f"gateway image build failed: {proc.stderr.strip()}")
 
@@ -149,79 +112,21 @@ class DockerGateway(Gateway):
         ])
         return self.name in proc.stdout.split()
 
-    def _running_image_is_current(self) -> bool:
-        """True iff the running gateway was created from the *current*
-        `image_ref`. When `ensure_built` rebuilds the image (a source change),
-        the running container is still the OLD image running the OLD flat
-        daemons — so this is how a rebuild actually takes effect: a mismatch
-        means recreate."""
-        running = run_docker(["docker", "inspect", "--format", "{{.Image}}", self.name])
-        current = run_docker(["docker", "image", "inspect", "--format", "{{.Id}}", self.image_ref])
-        if running.returncode != 0 or current.returncode != 0:
-            return True  # can't compare → don't churn a working container
-        return running.stdout.strip() == current.stdout.strip()
-
-    def _ensure_network(self) -> None:
-        """Create the shared gateway network if it doesn't exist. Idempotent —
-        a concurrent create loses harmlessly (the loser sees 'already exists').
-        Docker picks the subnet; the launcher reads it back to allocate IPs."""
-        if run_docker(["docker", "network", "inspect", self.network]).returncode == 0:
-            return
-        proc = run_docker(["docker", "network", "create", self.network])
-        if proc.returncode != 0 and "already exists" not in proc.stderr:
-            raise GatewayError(
-                f"gateway network {self.network} failed to create: {proc.stderr.strip()}"
-            )
-
     def ensure_running(self) -> None:
-        # Recreate when the running container's image is stale (a rebuild),
-        # so source changes to the gateway's flat daemons take effect — not
-        # just when the container is absent.
-        if self.is_running() and self._running_image_is_current():
+        if self.is_running():
             return
-        self._ensure_network()
-        # Clear any stale (stopped OR outdated-image) container holding the
-        # fixed name, then start fresh. `rm --force` on an absent name is a
-        # tolerated no-op.
+        # Clear any stale (stopped) container holding the fixed name, then
+        # start fresh. `rm --force` on an absent name is a tolerated no-op.
         run_docker(["docker", "rm", "--force", self.name])
-        argv = [
+        proc = run_docker([
             "docker", "run", "--detach",
             "--name", self.name,
             "--label", GATEWAY_LABEL,
-            "--network", self.network,
-            # Persist the self-generated CA so it survives restarts (agents
-            # trust it) — see GATEWAY_CA_VOLUME.
-            "--volume", f"{GATEWAY_CA_VOLUME}:{MITMPROXY_HOME}",
-        ]
-        for port in self._host_port_bindings:
-            argv += ["--publish", f"0.0.0.0:{port}:{port}"]
-        if self._orchestrator_url:
-            # Makes the gateway's egress / git / supervise daemons multi-tenant:
-            # each request resolves source-IP -> policy against the control plane.
-            argv += ["--env", f"BOT_BOTTLE_ORCHESTRATOR_URL={self._orchestrator_url}"]
-        argv.append(self.image_ref)
-        proc = run_docker(argv)
+            self.image_ref,
+        ])
         if proc.returncode != 0:
             raise GatewayError(f"gateway failed to start: {proc.stderr.strip()}")
 
-    def ca_cert_pem(self, *, timeout: float = DEFAULT_CA_TIMEOUT_SECONDS) -> str:
-        """The gateway's CA certificate (PEM) that agents install to trust its
-        TLS interception. mitmproxy generates it a moment after the container
-        starts, so this **polls** for it (up to `timeout`) rather than assuming
-        it's already there on a fresh gateway — raising only if it never
-        appears."""
-        deadline = time.monotonic() + timeout
-        while True:
-            proc = run_docker(["docker", "exec", self.name, "cat", GATEWAY_CA_CERT])
-            if proc.returncode == 0 and proc.stdout.strip():
-                return proc.stdout
-            if time.monotonic() >= deadline:
-                raise GatewayError(
-                    f"gateway CA cert not available after {timeout:g}s: "
-                    f"{proc.stderr.strip() or 'empty'}"
-                )
-            time.sleep(_CA_POLL_SECONDS)
-
     def stop(self) -> None:
         proc = run_docker(["docker", "rm", "--force", self.name])
         if proc.returncode != 0 and "No such container" not in proc.stderr:
@@ -230,6 +135,5 @@ class DockerGateway(Gateway):
 
 __all__ = [
     "Gateway", "DockerGateway", "GatewayError",
-    "GATEWAY_NAME", "GATEWAY_LABEL", "GATEWAY_IMAGE", "GATEWAY_NETWORK",
-    "GATEWAY_CA_VOLUME", "GATEWAY_CA_CERT",
+    "GATEWAY_NAME", "GATEWAY_LABEL", "GATEWAY_IMAGE",
 ]

bot_bottle/orchestrator/lifecycle.py

@@ -1,175 +0,0 @@
-"""Orchestrator + gateway lifecycle (PRD 0070, docker slice).
-
-Runs the orchestrator control plane **as a container** on the shared gateway
-network, alongside the gateway container. This is the PRD's "virtualize the
-orchestrator": container↔container between the gateway and the orchestrator
-avoids the host firewall (which drops container→host traffic), and the gateway
-reaches the control plane by container name over docker DNS. The host CLI
-reaches it via a published loopback port.
-
-The orchestrator runs with the **register-only broker** — the *backend*
-launches agent containers (compose), so the orchestrator needs no docker
-socket. That keeps this control-plane container unprivileged; the host manages
-both containers. `ensure_running` is an idempotent singleton (fixed container
-names + the published port).
-"""
-
-from __future__ import annotations
-
-import time
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-from .. import log
-from ..docker_cmd import run_docker
-from ..paths import bot_bottle_root
-from .gateway import GATEWAY_IMAGE, GATEWAY_NETWORK, DockerGateway
-
-DEFAULT_PORT = 8099
-ORCHESTRATOR_NAME = "bot-bottle-orchestrator"
-ORCHESTRATOR_LABEL = "bot-bottle-orchestrator=1"
-
-# The repo root is bind-mounted into the control-plane container so
-# `python -m bot_bottle.orchestrator` resolves the package (the orchestrator
-# is stdlib-only, so the bundle image's python is enough).
-_REPO_ROOT = Path(__file__).resolve().parents[2]
-_APP_DIR = "/app"
-_ROOT_IN_CONTAINER = "/bot-bottle-root"
-
-_HEALTH_POLL_SECONDS = 0.25
-DEFAULT_STARTUP_TIMEOUT_SECONDS = 45.0
-_HEALTH_REQUEST_TIMEOUT_SECONDS = 1.0
-
-
-class OrchestratorStartError(RuntimeError):
-    """The orchestrator container did not become healthy within the timeout."""
-
-
-class OrchestratorService:
-    """Manages the orchestrator control-plane container + the shared gateway.
-    Callers only need `ensure_running()` + `url`.
-
-    `orchestrator_name` / `orchestrator_label` let backends run independent
-    orchestrators on the same host without name collisions (e.g. the
-    Firecracker backend uses `bot-bottle-fc-orchestrator` alongside the Docker
-    backend's `bot-bottle-orchestrator`). Subclass and override `_gateway()`
-    to supply a backend-specific gateway variant."""
-
-    def __init__(
-        self,
-        *,
-        port: int = DEFAULT_PORT,
-        network: str = GATEWAY_NETWORK,
-        image: str = GATEWAY_IMAGE,
-        repo_root: Path = _REPO_ROOT,
-        host_root: Path | None = None,
-        orchestrator_name: str = ORCHESTRATOR_NAME,
-        orchestrator_label: str = ORCHESTRATOR_LABEL,
-    ) -> None:
-        self.port = port
-        self.network = network
-        self.image = image
-        self._repo_root = repo_root
-        self._host_root = host_root or bot_bottle_root()
-        self._orchestrator_name = orchestrator_name
-        self._orchestrator_label = orchestrator_label
-
-    @property
-    def url(self) -> str:
-        """Host-side control-plane URL (published loopback port)."""
-        return f"http://127.0.0.1:{self.port}"
-
-    @property
-    def internal_url(self) -> str:
-        """Control-plane URL as the gateway container reaches it — by name over
-        docker DNS on the shared network. This is the gateway's
-        BOT_BOTTLE_ORCHESTRATOR_URL."""
-        return f"http://{self._orchestrator_name}:{self.port}"
-
-    def is_healthy(self, *, timeout: float = _HEALTH_REQUEST_TIMEOUT_SECONDS) -> bool:
-        try:
-            with urllib.request.urlopen(f"{self.url}/health", timeout=timeout) as resp:
-                return resp.status == 200
-        except (urllib.error.URLError, TimeoutError, OSError):
-            return False
-
-    def _container_running(self, name: str) -> bool:
-        proc = run_docker(["docker", "ps", "--filter", f"name=^/{name}$", "--format", "{{.Names}}"])
-        return name in proc.stdout.split()
-
-    def _run_orchestrator_container(self) -> None:
-        """Start the control-plane container (idempotent: clears a stale
-        fixed-name container first). Register-only broker → no docker socket."""
-        run_docker(["docker", "rm", "--force", self._orchestrator_name])
-        proc = run_docker([
-            "docker", "run", "--detach",
-            "--name", self._orchestrator_name,
-            "--label", self._orchestrator_label,
-            "--network", self.network,
-            # Host CLI reaches the control plane here; bound to loopback so it
-            # is not exposed on the host's external interfaces.
-            "--publish", f"127.0.0.1:{self.port}:{self.port}",
-            "--volume", f"{self._repo_root}:{_APP_DIR}:ro",
-            "--workdir", _APP_DIR,
-            # Persist the registry DB on the host (sole-owner: only the
-            # orchestrator opens bot-bottle.db).
-            "--volume", f"{self._host_root}:{_ROOT_IN_CONTAINER}",
-            "--env", f"BOT_BOTTLE_ROOT={_ROOT_IN_CONTAINER}",
-            "--entrypoint", "python3",
-            self.image,
-            "-m", "bot_bottle.orchestrator",
-            "--host", "0.0.0.0", "--port", str(self.port), "--broker", "stub",
-        ])
-        if proc.returncode != 0:
-            raise OrchestratorStartError(
-                f"orchestrator container failed to start: {proc.stderr.strip()}"
-            )
-
-    def _gateway(self) -> DockerGateway:
-        return DockerGateway(self.image, network=self.network, orchestrator_url=self.internal_url)
-
-    def ensure_running(
-        self, *, startup_timeout: float = DEFAULT_STARTUP_TIMEOUT_SECONDS,
-    ) -> str:
-        """Ensure the control plane + shared gateway are up; return the host
-        control-plane URL. Idempotent — a healthy control plane and a running
-        gateway are left untouched. Raises `OrchestratorStartError` on
-        timeout."""
-        gateway = self._gateway()
-        gateway.ensure_built()  # rebuild the bundle image on a source change
-        gateway.ensure_running()  # creates the shared network + (re)starts gateway
-
-        # Always (re)create the orchestrator container. It runs the repo's code
-        # bind-mounted, but the Python process loaded that code at startup and
-        # won't reload — so reusing a healthy-but-stale container would keep
-        # running OLD control-plane code (e.g. dropping the tokens field). Cheap
-        # (~seconds); the registry DB persists and the current launch
-        # re-registers its own in-memory state. (The dedicated orchestrator
-        # image follow-up replaces this with image-staleness detection.)
-        log.info("starting orchestrator container", context={"name": self._orchestrator_name})
-        self._run_orchestrator_container()
-
-        deadline = time.monotonic() + startup_timeout
-        while time.monotonic() < deadline:
-            if self.is_healthy():
-                log.info("orchestrator healthy", context={"url": self.url})
-                return self.url
-            time.sleep(_HEALTH_POLL_SECONDS)
-        raise OrchestratorStartError(
-            f"orchestrator at {self.url} did not become healthy within {startup_timeout:g}s"
-        )
-
-    def stop(self) -> None:
-        """Remove the orchestrator + gateway containers (idempotent)."""
-        run_docker(["docker", "rm", "--force", self._orchestrator_name])
-        self._gateway().stop()
-
-
-__all__ = [
-    "OrchestratorService",
-    "OrchestratorStartError",
-    "ORCHESTRATOR_NAME",
-    "DEFAULT_PORT",
-    "DEFAULT_STARTUP_TIMEOUT_SECONDS",
-]

bot_bottle/orchestrator/registration.py

@@ -1,57 +0,0 @@
-"""Consolidated registration inputs (PRD 0070, docker slice).
-
-Bridges the existing per-bottle `prepare` output to the consolidated
-registry: turns a prepared bottle's egress plan into the backend-neutral
-inputs `Orchestrator.launch_bottle` takes — the egress **policy** blob and
-launch **metadata**.
-
-The policy blob is the exact routes YAML the per-bottle egress sidecar used
-to read from a file; in the consolidated model the multi-tenant gateway's
-`PolicyResolver` fetches it from the registry per request (keyed by source
-IP) instead. Same render, so consolidated and single-tenant egress apply
-byte-identical policy — a bottle's allow-list doesn't change when it moves
-onto the shared gateway.
-
-Host-side glue (imports `bot_bottle.egress`), used by the launch path — not
-by the lean orchestrator control-plane process itself.
-"""
-
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass
-
-from ..egress import EgressPlan, egress_render_routes
-
-
-@dataclass(frozen=True)
-class RegistrationInputs:
-    """What `Orchestrator.launch_bottle` needs to register a bottle, derived
-    from its prepared plan. `policy` is served verbatim by the gateway's
-    `/resolve`; `metadata` is opaque forward-compat state — it carries the
-    human slug so the console / supervise can show a name, not just the
-    minted bottle id."""
-
-    policy: str
-    metadata: str
-
-
-def egress_policy(plan: EgressPlan) -> str:
-    """The bottle's egress policy blob: the routes YAML the gateway serves
-    and the addon parses with `load_config`. Identical to the per-bottle
-    `routes.yaml` render, so the consolidated path applies the same
-    allow-list."""
-    return egress_render_routes(plan.routes, log=plan.log)
-
-
-def registration_inputs(plan: EgressPlan) -> RegistrationInputs:
-    """Assemble the orchestrator registration inputs from a prepared egress
-    plan. `metadata` records the slug so the shared registry can map a minted
-    bottle id back to its human name."""
-    return RegistrationInputs(
-        policy=egress_policy(plan),
-        metadata=json.dumps({"slug": plan.slug}),
-    )
-
-
-__all__ = ["RegistrationInputs", "egress_policy", "registration_inputs"]

bot_bottle/orchestrator/registry.py

@@ -149,15 +149,7 @@ class RegistryStore(DbStore):
         policy: str = "",
     ) -> BottleRecord:
         """Register (or replace) a bottle. Mints a bottle_id / identity token
-        when not supplied. Live — this is the control-plane reload path.
-
-        Supersedes any *other* active bottle at the same source IP first:
-        `by_source_ip` fail-closes on ambiguity (>1 active row → None), so a
-        leftover row at a reused IP — from an untorn-down bottle, crash
-        recovery, or a persisted DB — would otherwise *brick* the new bottle's
-        attribution. The new registration is authoritative for its IP; the
-        stale rows go. INSERT OR REPLACE handles a same-`bottle_id` reload in
-        place (its own row is exempt from the sweep)."""
+        when not supplied. Live — this is the control-plane reload path."""
         rec = BottleRecord(
             bottle_id=bottle_id or secrets.token_hex(8),
             source_ip=source_ip,
@@ -168,11 +160,6 @@ class RegistryStore(DbStore):
             policy=policy,
         )
         with self._connect() as conn:
-            conn.execute(
-                "DELETE FROM orchestrator_bottles "
-                "WHERE source_ip = ? AND state = 'active' AND bottle_id != ?",
-                (rec.source_ip, rec.bottle_id),
-            )
             conn.execute(
                 "INSERT OR REPLACE INTO orchestrator_bottles "
                 "(bottle_id, source_ip, identity_token, state, created_at, metadata, policy) "

bot_bottle/orchestrator/service.py

@@ -38,12 +38,6 @@ class Orchestrator:
         self._broker = broker
         self._secret = sign_secret
         self._gateway = gateway
-        # Per-bottle egress auth tokens (env_name -> value), keyed by bottle_id.
-        # Held **in memory only** — never written to the registry DB — so the
-        # gateway can inject each bottle's upstream credential without secrets
-        # at rest. Lost on restart (re-launch re-registers them); the future
-        # SecretProvider (#355) replaces this with per-request minting.
-        self._tokens: dict[str, dict[str, str]] = {}
 
     def launch_bottle(
         self,
@@ -53,14 +47,11 @@ class Orchestrator:
         slot: int | None = None,
         metadata: str = "",
         policy: str = "",
-        tokens: dict[str, str] | None = None,
     ) -> BottleRecord:
-        """Register a bottle (with its gateway policy + in-memory egress auth
-        tokens) and broker its launch. Rolls the registry entry back if the
-        launch doesn't take, so a failure leaves no orphan."""
+        """Register a bottle (with its gateway policy) and broker its launch.
+        Rolls the registry entry back if the launch doesn't take, so a
+        failure leaves no orphan."""
         rec = self.registry.register(source_ip, metadata=metadata, policy=policy)
-        if tokens:
-            self._tokens[rec.bottle_id] = dict(tokens)
         req = LaunchRequest(
             op="launch",
             bottle_id=rec.bottle_id,
@@ -75,7 +66,6 @@ class Orchestrator:
         finally:
             if not launched:
                 self.registry.deregister(rec.bottle_id)
-                self._tokens.pop(rec.bottle_id, None)
         return rec
 
     def teardown_bottle(self, bottle_id: str) -> bool:
@@ -86,15 +76,8 @@ class Orchestrator:
         req = LaunchRequest(op="teardown", bottle_id=bottle_id, source_ip=rec.source_ip)
         self._broker.submit(sign_request(req, self._secret))
         self.registry.deregister(bottle_id)
-        self._tokens.pop(bottle_id, None)
         return True
 
-    def tokens_for(self, bottle_id: str) -> dict[str, str]:
-        """The bottle's in-memory egress auth tokens (env_name -> value), or
-        empty. The gateway injects these per request; they are never
-        persisted."""
-        return dict(self._tokens.get(bottle_id, {}))
-
     def attribute(self, source_ip: str, identity_token: str) -> BottleRecord | None:
         """Fail-closed attribution (delegates to the registry)."""
         return self.registry.attribute(source_ip, identity_token)

bot_bottle/policy_resolver.py

@@ -102,26 +102,21 @@ class PolicyResolver:
 
     def resolve_policy_and_bottle_id(
         self, source_ip: str, identity_token: str = "",
-    ) -> tuple[str | None, str | None, dict[str, str]]:
-        """The policy blob, bottle id, **and per-bottle egress auth tokens** in
-        a single `/resolve` — so the egress addon gets everything it needs
-        (policy for routing, bottle id for the supervise queue/safelist, tokens
-        to inject upstream auth) in one round-trip. Returns `(None, None, {})`
-        when unattributed (a clean `403`). Raises `PolicyResolveError` if the
-        orchestrator can't be reached, so the caller still fails closed."""
+    ) -> tuple[str | None, str | None]:
+        """Both the policy blob and the bottle id in a single `/resolve` — so
+        a caller that needs each (the egress addon: policy for routing, bottle
+        id to key the calling bottle's supervise queue + safelist) makes one
+        round-trip, not two. Returns `(None, None)` when unattributed (a clean
+        `403`). Raises `PolicyResolveError` if the orchestrator can't be
+        reached, so the caller still fails closed."""
         payload = self._post_resolve(source_ip, identity_token)
         if payload is None:
-            return None, None, {}
+            return None, None
         policy = payload.get("policy")
         bottle_id = payload.get("bottle_id")
-        raw = payload.get("tokens")
-        tokens = {
-            k: v for k, v in raw.items() if isinstance(k, str) and isinstance(v, str)
-        } if isinstance(raw, dict) else {}
         return (
             policy if isinstance(policy, str) else "",
             bottle_id if isinstance(bottle_id, str) and bottle_id else None,
-            tokens,
         )
 
 

bot_bottle/supervise_server.py

@@ -15,12 +15,6 @@ The bottle slug arrives via SUPERVISE_BOTTLE_SLUG env (stamped at
 container creation by the backend's start step). SUPERVISE_DB_PATH
 points at the bind-mounted host database.
 
-Consolidated (PRD 0070): when BOT_BOTTLE_ORCHESTRATOR_URL is set, one
-shared server fronts every bottle and attributes each proposal to the
-calling bottle by source IP (resolved from the orchestrator) instead of a
-fixed slug — an unattributed source fails closed. Unset → the legacy
-per-bottle single-tenant server, unchanged.
-
 Speaks MCP over HTTP+JSON-RPC. Methods handled:
 
   * `initialize`           — handshake; returns server info + caps.
@@ -46,18 +40,16 @@ import time
 import typing
 import urllib.error
 import urllib.request
-from dataclasses import dataclass, replace
+from dataclasses import dataclass
 
 try:
     # Same-directory imports inside the bundle container; these files are
     # COPYed flat under /app by Dockerfile.sidecars.
     from egress_addon_core import LOG_OFF, load_config
-    from policy_resolver import PolicyResolveError, PolicyResolver
     import supervise as _sv
 except ModuleNotFoundError:
     # Package imports for host-side tests and tooling.
     from .egress_addon_core import LOG_OFF, load_config
-    from .policy_resolver import PolicyResolveError, PolicyResolver
     from . import supervise as _sv
 
 
@@ -81,12 +73,6 @@ DEFAULT_RESPONSE_TIMEOUT_SECONDS = 30.0
 MIN_RESPONSE_POLL_INTERVAL_SECONDS = 0.05
 EGRESS_LIST_TIMEOUT_SECONDS = 5.0
 
-# Consolidated (multi-tenant) mode: when set, one shared supervise server
-# fronts every bottle and attributes each proposal to the calling bottle by
-# source IP (resolved from the orchestrator), instead of a single
-# SUPERVISE_BOTTLE_SLUG env. Unset → legacy per-bottle single-tenant.
-ORCHESTRATOR_URL_ENV = "BOT_BOTTLE_ORCHESTRATOR_URL"
-
 
 @dataclass(frozen=True)
 class JsonRpcRequest:
@@ -525,30 +511,9 @@ class MCPHandler(http.server.BaseHTTPRequestHandler):
         if method == "tools/list":
             return handle_tools_list(req.params)
         if method == "tools/call":
-            # Attribute the proposal to the calling bottle. Single-tenant → the
-            # env slug on `config`; consolidated → the source-IP-resolved
-            # bottle id, so one shared server queues each bottle's proposal
-            # under its own slug.
-            return handle_tools_call(req.params, self._attributed_config(config))
+            return handle_tools_call(req.params, config)
         raise _RpcClientError(ERR_METHOD_NOT_FOUND, f"method not found: {method}")
 
-    def _attributed_config(self, config: ServerConfig) -> ServerConfig:
-        """The ServerConfig with `bottle_slug` bound to *this request's* bottle.
-        Single-tenant (no resolver): unchanged. Consolidated: the bottle id
-        attributed from the source IP — **fail-closed**, an unattributed or
-        unreachable source raises so no proposal is queued under the wrong (or
-        empty) slug."""
-        resolver = getattr(self.server, "policy_resolver", None)
-        if resolver is None:
-            return config
-        try:
-            bottle_id = resolver.resolve_bottle_id(self.client_address[0])
-        except PolicyResolveError as e:
-            raise _RpcInternalError(f"orchestrator unreachable, cannot attribute: {e}") from e
-        if not bottle_id:
-            raise _RpcInternalError("request source is not attributed to a bottle")
-        return replace(config, bottle_slug=bottle_id)
-
     def _write_jsonrpc(self, body: bytes) -> None:
         self.send_response(200)
         self.send_header("Content-Type", "application/json")
@@ -572,9 +537,6 @@ class MCPServer(socketserver.ThreadingMixIn, http.server.HTTPServer):
     allow_reuse_address = True
     daemon_threads = True
     config: ServerConfig = ServerConfig(bottle_slug="")
-    # None → single-tenant (proposals use config.bottle_slug); set → consolidated
-    # (each proposal attributed to the source-IP-resolved bottle).
-    policy_resolver: "PolicyResolver | None" = None
 
 
 # --- Entry point -----------------------------------------------------------
@@ -586,17 +548,15 @@ def serve(
     port: int = _sv.SUPERVISE_PORT,
     bind: str = "0.0.0.0",
     response_timeout_seconds: float = DEFAULT_RESPONSE_TIMEOUT_SECONDS,
-    resolver: "PolicyResolver | None" = None,
 ) -> typing.NoReturn:
     server = MCPServer((bind, port), MCPHandler)
     server.config = ServerConfig(
         bottle_slug=bottle_slug,
         response_timeout_seconds=response_timeout_seconds,
     )
-    server.policy_resolver = resolver
-    mode = "multi-tenant" if resolver else f"slug={bottle_slug!r}"
     sys.stderr.write(
-        f"supervise listening on {bind}:{port}; {mode}; "
+        f"supervise listening on {bind}:{port}; "
+        f"slug={bottle_slug!r}; "
         f"tools: {', '.join(t['name'] for t in TOOL_DEFINITIONS)}\n"  # type: ignore[arg-type]
     )
     sys.stderr.flush()
@@ -611,12 +571,8 @@ def serve(
 
 def main(argv: list[str]) -> int:
     del argv  # config is env-only, no CLI flags
-    orch_url = os.environ.get(ORCHESTRATOR_URL_ENV, "").strip()
-    resolver = PolicyResolver(orch_url) if orch_url else None
     bottle_slug = os.environ.get("SUPERVISE_BOTTLE_SLUG", "")
-    # Consolidated mode resolves the slug per request, so the env slug is
-    # optional there; single-tenant still requires it.
-    if not bottle_slug and resolver is None:
+    if not bottle_slug:
         sys.stderr.write("supervise: SUPERVISE_BOTTLE_SLUG env is unset\n")
         return 2
     port = int(os.environ.get("SUPERVISE_PORT", str(_sv.SUPERVISE_PORT)))
@@ -631,7 +587,6 @@ def main(argv: list[str]) -> int:
         port=port,
         bind=bind,
         response_timeout_seconds=response_timeout_seconds,
-        resolver=resolver,
     )
     return 0  # serve() does not return
 

docs/research/agent-credential-proxy-landscape.md

@@ -15,25 +15,6 @@ the biggest credential risk).
 
 ## Summary
 
-> **Status — implemented (2026-07-14).** This note's recommendation
-> shipped, so the "today" / "in-flight" tenses below are now historical
-> (kept as the reasoning that led here). Current reality: bot-bottle no
-> longer injects raw provider tokens into the agent. The agent's environ
-> carries only a **placeholder** (e.g.
-> `CLAUDE_CODE_OAUTH_TOKEN=egress-placeholder`); the real token is held
-> in the egress sidecar and injected as the upstream `Authorization`
-> header. Rather than adding a *separate* in-container reverse proxy (as
-> proposed below), credential injection was folded into the **existing
-> pipelock/mitmproxy egress firewall**: an `EgressRoute` carries
-> `auth_scheme` + `token_ref`, the host token is forwarded into the
-> sidecar addon under an `EGRESS_TOKEN_N` slot, and the addon rewrites
-> `Authorization` on matching routes — **one MITM, not two** (this
-> resolves the Infisical-doubling concern noted later). The same
-> mechanism now covers Codex and Pi provider tokens and git-host PATs.
-> A `printenv` inside the bottle yields the placeholder, not the secret.
-> For current wiring see `bot_bottle/egress.py` and
-> `bot_bottle/contrib/*/agent_provider.py`.
-
 Today every bot-bottle agent gets `CLAUDE_CODE_OAUTH_TOKEN` (and
 any `bottle.env` secrets like a Gitea PAT) injected as env vars,
 which means the agent process can read them with `printenv` or
@@ -55,24 +36,6 @@ small bot-bottle-specific reverse proxy modeled on the
 phantom-token shape is probably the right call. For Gitea / GitHub /
 GitLab, the same proxy generalizes by config.
 
-**Updated 2026-07-14:** OneCLI ([onecli.sh](https://onecli.sh/)) —
-already listed below — has matured into a GA, YC-backed Rust
-credential gateway ("The Identity Gateway for AI Agents", ~2.5k⭐,
-300k+ downloads) that implements the **same phantom-token pattern**
-this note recommends: the agent holds a placeholder token, the
-gateway swaps it for the real (AES-256-GCM-encrypted) credential at
-request time. It's now the most mature open-source realization of the
-exact design proposed here — a production-ready alternative to
-alpha-stage nono — at the cost of being a broader product (built-in
-vault + management dashboard + hosted cloud tier + 50+ app
-integrations) rather than a minimal proxy. Its managed/cloud tier and
-per-agent dashboard also overlap bot-bottle's own planned paid control
-plane (bot-bottle-console, issue #327), so it's worth tracking as both
-a build-vs-adopt option *and* a product-level competitor. The
-build-first recommendation still stands (see synthesis below), but
-adopting OneCLI's OSS core is now a credible alternative where nono was
-too green.
-
 ## The shared problem
 
 Linux has no per-env-var ACL. Once a var is in a process's
@@ -114,9 +77,7 @@ The remaining credible designs reduce to three:
 
 ### Anthropic / Claude Code
 
-**Original wiring** (pre-gateway; **superseded 2026-07-14** — see the
-Status note in the Summary; the token now lives in the egress sidecar
-and the agent gets a placeholder): the host's
+**Today's wiring** (`bot_bottle/cli/start.py`): the host's
 `BOT_BOTTLE_CLAUDE_OAUTH_TOKEN` is forwarded into the bottle as
 `CLAUDE_CODE_OAUTH_TOKEN` via `docker run -e CLAUDE_CODE_OAUTH_TOKEN`
 (no `=value`, so the value never lands on argv — good). Inside the
@@ -262,7 +223,7 @@ Two categories:
 | **Infisical Agent Vault** | B | MIT (EE carve-out) | In-process HTTPS_PROXY forward proxy | TLS MITM, dummy-to-real swap | No — HTTPS_PROXY model | Service-level | Active; v0.19.0 May 2026, ~1k⭐ |
 | **nono** | B | Apache-2.0 | In-process reverse proxy | Phantom token, explicit URL routing | **Yes** — `BASE_URL=http://127.0.0.1:PORT/…` | Host + endpoint | Early alpha; v0.53.0 May 2026, 2.4k⭐ |
 | **Aegis** | B | Apache-2.0 | In-process reverse proxy | Path routing (`localhost:3100/{svc}/…`) | Configurable, undocumented for Anthropic | Method/path/rate/time | Very new, 10⭐ |
-| **OneCLI** | B | Apache-2.0 | Reverse proxy + built-in vault + dashboard | **Phantom token** (placeholder→real swap at request time), AES-256-GCM vault | Yes (host match) | Per-agent + endpoint/method + rate limits | GA; Rust; YC-backed; ~2.5k⭐, 300k+ downloads (Jul 2026) |
+| **OneCLI** | B | Apache-2.0 | Reverse proxy + management UI | Host/path matching, Bitwarden integration | Configurable | Per-agent scoping | Active; v1.23.0 May 2026, 2.1k⭐ |
 | **Aembit** | B | Proprietary | Sidecar + cloud control plane | TLS intercept, SPIFFE, JIT creds | No — intercepts by destination | Policy-based | GA (Apr 2026) |
 | **LiteLLM Proxy** | A | MIT | Reverse proxy | Virtual key → upstream key | Yes — set base URL to LiteLLM | Route-level | 45k⭐; **CVE-2026-42208 exploited Apr 2026**, patch v1.83.7 |
 | **Portkey Gateway** | A | MIT (OSS core) | Reverse proxy | Virtual key vault (cloud or Enterprise self-host) | Yes — documented for Claude Code | Config-based | Production; virtual-key vault needs Enterprise for self-host |
@@ -281,18 +242,6 @@ Two categories:
   `ANTHROPIC_BASE_URL`. **Blocker:** nono is explicitly
   "early alpha, not security audited."
 
-  **Update (2026-07-14):** OneCLI ([onecli.sh](https://onecli.sh/))
-  ships the same phantom-token shape but is GA and YC-backed (Rust,
-  ~2.5k⭐, 300k+ downloads) — the maturity nono lacks. Trade-offs: it's
-  a full identity-gateway *product* (encrypted vault, management
-  dashboard, 50+ one-click app integrations, hosted cloud tier), much
-  heavier than the ~100-line proxy proposed below, and its hosted tier
-  is a third-party credential custodian — precisely the trust
-  dependency bot-bottle's isolation model exists to avoid. So: its
-  Apache-2.0 OSS core is a credible *adopt* candidate for the
-  phantom-token slice; its managed offering is a *competitor*, not a
-  dependency to lean on.
-
 - **TLS-MITM forward proxies** (Infisical Agent Vault, Cloudflare
   Sandbox Auth, Aembit, the existing pipelock) all double up on
   the CA-trust machinery PRD 0006 already built for pipelock.
@@ -324,15 +273,6 @@ routing matches the design recommended here exactly; zero TLS
 work. But "not security audited" + "early alpha" means adopting it
 is a bet on the project rather than a buy-vs-build win.
 
-**Mature phantom-token option (added 2026-07-14):** OneCLI — same
-architecture as nono, but GA, Rust, and YC-backed. Its Apache-2.0 OSS
-core is now the strongest *adopt* candidate for the phantom-token slice
-if building is undesirable; the caveats are product surface you don't
-need (bundled vault + dashboard) and that its hosted tier is a
-competitor rather than a dependency. Doesn't change the build-first
-recommendation for the narrow Anthropic-token slice, but it does mean
-"is there a mature drop-in?" now has a real answer.
-
 **Most mature OSS purpose-built:** Infisical Agent Vault. MIT,
 v0.19.0 active, v0.17.0 added a containerized agent mode that
 maps directly to bot-bottle. Friction is the TLS-MITM topology
@@ -353,12 +293,6 @@ exposed.
 
 ## Recommended path forward
 
-> **Mostly implemented (2026-07-14).** Steps 1–3 shipped — the token
-> injection moved into the egress sidecar (folded into pipelock rather
-> than a standalone reverse proxy) and generalized to Codex/Pi/git-host
-> tokens. Steps 4–5 (issuance-side scope narrowing, per-route allowlists)
-> remain good hygiene. See the Status note in the Summary.
-
 In priority order:
 
 1. **In-container reverse proxy holding `CLAUDE_CODE_OAUTH_TOKEN`.**
@@ -442,9 +376,6 @@ already gives us for upstream push credentials.
 - [nono — phantom token blog](https://nono.sh/blog/blog-credential-injection)
 - [Aegis — GitHub](https://github.com/getaegis/aegis)
 - [OneCLI — GitHub](https://github.com/onecli/onecli)
-- [OneCLI — homepage](https://onecli.sh/)
-- [OneCLI — Y Combinator company page](https://www.ycombinator.com/companies/onecli)
-- [Show HN: OneCLI – Vault for AI Agents in Rust](https://news.ycombinator.com/item?id=47353558)
 - [Sandbox0 — GitHub](https://github.com/sandbox0-ai/sandbox0)
 - [Buildkite Cleanroom — GitHub](https://github.com/buildkite/cleanroom)
 - [Aembit IAM for Agentic AI — GA](https://aembit.io/blog/aembit-iam-for-agentic-ai-is-now-generally-available/)

docs/research/landscape-containerized-claude.md

@@ -71,56 +71,6 @@ manifest merge.
   network egress is logged by pipelock/mitmproxy, and per-run op-log/audit state
   is persisted to SQLite.
 
-- **OneCLI** ([onecli.sh](https://onecli.sh/)) — YC-backed, GA, open-source
-  (Apache-2.0, Rust) "identity gateway for AI agents": a credential/secret
-  broker that holds API keys and OAuth tokens out of the agent's reach and
-  injects them at the network layer (phantom-token — the agent sees a
-  placeholder, the gateway swaps in the real, AES-256-GCM-encrypted credential
-  at request time). Framework-agnostic and drop-in for any HTTP-calling agent,
-  50+ app integrations, plus a hosted cloud tier with a per-agent dashboard and
-  audit logs. Full technical breakdown in
-  [`agent-credential-proxy-landscape.md`](agent-credential-proxy-landscape.md).
-
-  **How close a competitor:** near-exact on the *single axis of agent secret
-  custody* — the exact thing bot-bottle sells as "the agent never sees real
-  credentials, even via `printenv`." OneCLI does that one job well, is mature
-  and funded, and is *more portable* (it sits in front of anything; bot-bottle
-  only helps agents launched through bot-bottle). Takeaway: bot-bottle should
-  stop treating secret custody as a *unique* differentiator. But OneCLI is
-  **not** a competitor to bot-bottle's actual product — it does no agent
-  sandboxing (containers/microVMs), no fleet/manifest layer, no named agents /
-  skills / per-agent system prompts, no multi-provider launching, no egress
-  firewall.
-
-  **Our edge:** (1) *Isolation is the product, not a proxy.* OneCLI keeps the
-  key out of reach at the network layer, but the agent itself still runs
-  unsandboxed — a hijacked agent behind OneCLI has full run of its host and can
-  exfil captured data through any allowed host. bot-bottle runs the agent inside
-  a kernel/VM-enforced sandbox, injects credentials across that same
-  out-of-process boundary, *and* clamps egress with pipelock — defense in depth
-  vs. a single network layer. (2) *Fleet + manifest model* with named agents,
-  skills, per-agent system prompts, multi-provider and multi-backend — OneCLI
-  has no equivalent. (3) *Trust posture:* OneCLI's managed tier reintroduces a
-  third-party credential custodian, whereas bot-bottle's OSS-runtime +
-  paid-control-plane split keeps custody inside the operator's own boundary —
-  the stronger story for the security-minded self-hoster. (4) *Runs inside your
-  network boundary — local/internal reach.* Because bot-bottle executes the
-  agent on your own host (homelab, corporate LAN, a Tailnet) and egress is a
-  manifest field, giving an agent *scoped* access to **internal** resources — a
-  private Gitea, a LAN database, a Tailscale node — is just another egress-route
-  line, not a networking project (the same move an operator already makes to
-  reach their Tailscale services). OneCLI's OSS core can self-host too, but it's
-  a credential *broker* for outbound API calls, not an agent runtime, and its
-  managed tier + 50+ integrations are oriented at public SaaS — it doesn't put
-  the agent behind your firewall for you. This is a reach advantage, distinct
-  from the isolation ones above, and it's a wedge cloud-first agent products
-  (Devin, Copilot Workspace, OneCLI Cloud) structurally can't match. **Tactical
-  read:**
-  adopt OneCLI's OSS core for the credential slice if building is undesirable
-  (it's mature now); don't build atop its managed tier (competitor, not
-  dependency); re-position bot-bottle on isolation + fleet + self-hosted custody
-  rather than "we hide your secrets."
-
 ## What no found project does
 
 None combine:

tests/integration/test_multitenant_isolation.py

@@ -1,161 +0,0 @@
-"""Integration: two bottles share one gateway; source-IP attribution keeps
-their egress tokens *and* allowlists isolated (PRD 0070 multi-tenancy).
-
-The whole premise of the consolidation is one shared gateway for every
-bottle, isolated only by the unspoofable source IP. A single-bottle test
-can't catch cross-bottle token bleed or an allowlist leak — this brings up
-the real orchestrator + gateway and drives two bottles through the one
-gateway to prove each gets exactly its own token and its own routes.
-
-Gated on a reachable Docker daemon and builds the bundle image, so it runs
-with the other docker integration tests, not in unit CI. Uses the real
-fixed gateway/orchestrator names (that's what it's testing), so it can't run
-concurrently with a live per-host gateway; it points the orchestrator at a
-throwaway BOT_BOTTLE_ROOT for a clean registry and tears everything down.
-"""
-
-from __future__ import annotations
-
-import os
-import subprocess
-import tempfile
-import unittest
-from pathlib import Path
-
-from bot_bottle.backend.docker.consolidated_launch import (
-    _network_cidr,
-    _network_container_ips,
-)
-from bot_bottle.backend.docker.egress import EGRESS_PORT
-from bot_bottle.backend.docker.gateway_net import next_free_ip
-from bot_bottle.orchestrator.client import OrchestratorClient
-from bot_bottle.orchestrator.gateway import GATEWAY_IMAGE, GATEWAY_NAME, GATEWAY_NETWORK
-from bot_bottle.orchestrator.lifecycle import OrchestratorService
-from tests._docker import skip_unless_docker
-
-# One upstream reachable under two names; reflects the Authorization header so
-# the probe can see exactly what the gateway injected (or didn't).
-_ECHO_NAME = "bot-bottle-mtitest-echo"
-_ECHO_ALIASES = ("echo-shared", "echo-bonly")
-_ECHO_SRC = (
-    "from http.server import BaseHTTPRequestHandler, HTTPServer\n"
-    "class H(BaseHTTPRequestHandler):\n"
-    " def do_GET(s):\n"
-    "  a=s.headers.get('Authorization','NONE'); s.send_response(200); s.end_headers()\n"
-    "  s.wfile.write(('AUTH='+a).encode())\n"
-    " def log_message(s,*a): pass\n"
-    "HTTPServer(('0.0.0.0',80),H).serve_forever()\n"
-)
-
-# A: echo-shared only, authed.  B: echo-shared authed + echo-bonly open.
-_POLICY_A = (
-    'routes:\n'
-    '  - host: echo-shared\n'
-    '    auth_scheme: "Bearer"\n'
-    '    token_env: "EGRESS_TOKEN_0"\n'
-)
-_POLICY_B = _POLICY_A + '  - host: echo-bonly\n'
-_TOKEN_A = "sk-AAA-alice"
-_TOKEN_B = "sk-BBB-bob"
-
-# Client probe: open http://<host>/ through the gateway proxy from a container
-# pinned to the bottle's source IP, printing "<status> <body>". Uses only the
-# bundle image's python3 — no dependency on the agent image.
-_PROBE_SRC = (
-    "import sys,urllib.request,urllib.error\n"
-    "op=urllib.request.build_opener(urllib.request.ProxyHandler({'http':sys.argv[1]}))\n"
-    "try:\n"
-    " r=op.open('http://'+sys.argv[2]+'/',timeout=8)\n"
-    " sys.stdout.write(str(r.status)+' '+r.read().decode())\n"
-    "except urllib.error.HTTPError as e:\n"
-    " sys.stdout.write(str(e.code)+' '+e.read().decode())\n"
-)
-
-
-@skip_unless_docker()
-@unittest.skipIf(
-    os.environ.get("GITEA_ACTIONS") == "true",
-    "skipped under act_runner: the orchestrator container bind-mounts the repo "
-    "path into a container on the socket-shared host daemon, which can't see the "
-    "runner's /workspace — same host-bind-mount constraint as the other "
-    "bottle-bringup integration tests",
-)
-class TestMultitenantIsolation(unittest.TestCase):
-    def setUp(self) -> None:
-        self._tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self._tmp.cleanup)
-        # Throwaway root → a clean registry DB, independent of the host's.
-        self.svc = OrchestratorService(host_root=Path(self._tmp.name))
-        self.addCleanup(self._teardown_docker)
-        # ensure_running builds the bundle image (slow on a cold cache) and
-        # brings up the shared network + gateway + orchestrator.
-        url = self.svc.ensure_running(startup_timeout=300)
-        self.client = OrchestratorClient(url)
-        self.gw_ip = self._container_ip(GATEWAY_NAME)
-        self._run_echo()
-
-    def _teardown_docker(self) -> None:
-        subprocess.run(["docker", "rm", "--force", _ECHO_NAME],
-                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
-        self.svc.stop()
-        subprocess.run(["docker", "network", "rm", GATEWAY_NETWORK],
-                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
-        # The orchestrator container wrote the registry DB as root into the
-        # throwaway root; chown it back so the (non-root) tempdir cleanup can
-        # remove it.
-        subprocess.run(
-            ["docker", "run", "--rm", "-v", f"{self._tmp.name}:/r",
-             "--entrypoint", "chown", GATEWAY_IMAGE, "-R",
-             f"{os.getuid()}:{os.getgid()}", "/r"],
-            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
-
-    @staticmethod
-    def _container_ip(name: str) -> str:
-        proc = subprocess.run(
-            ["docker", "inspect", "-f",
-             '{{(index .NetworkSettings.Networks "' + GATEWAY_NETWORK + '").IPAddress}}', name],
-            stdout=subprocess.PIPE, text=True, check=True,
-        )
-        return proc.stdout.strip()
-
-    def _run_echo(self) -> None:
-        argv = ["docker", "run", "--detach", "--name", _ECHO_NAME,
-                "--network", GATEWAY_NETWORK]
-        for alias in _ECHO_ALIASES:
-            argv += ["--network-alias", alias]
-        argv += ["--entrypoint", "python3", GATEWAY_IMAGE, "-c", _ECHO_SRC]
-        proc = subprocess.run(argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                              text=True, check=False)
-        self.assertEqual(0, proc.returncode, f"echo upstream failed: {proc.stderr}")
-
-    def _free_ip(self, extra_taken: list[str]) -> str:
-        taken = _network_container_ips(GATEWAY_NETWORK) + extra_taken
-        return next_free_ip(_network_cidr(GATEWAY_NETWORK), taken)
-
-    def _probe(self, source_ip: str, host: str) -> str:
-        proc = subprocess.run(
-            ["docker", "run", "--rm", "--network", GATEWAY_NETWORK, "--ip", source_ip,
-             "--entrypoint", "python3", GATEWAY_IMAGE, "-c", _PROBE_SRC,
-             f"http://{self.gw_ip}:{EGRESS_PORT}", host],
-            stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=False, timeout=90,
-        )
-        return proc.stdout.strip()
-
-    def test_two_bottles_share_gateway_with_isolated_tokens_and_allowlists(self) -> None:
-        ip_a = self._free_ip([])
-        ip_b = self._free_ip([ip_a])
-        self.client.register_bottle(ip_a, policy=_POLICY_A, tokens={"EGRESS_TOKEN_0": _TOKEN_A})
-        self.client.register_bottle(ip_b, policy=_POLICY_B, tokens={"EGRESS_TOKEN_0": _TOKEN_B})
-
-        # Each bottle gets its OWN token injected on the shared route — no bleed.
-        self.assertEqual(f"200 AUTH=Bearer {_TOKEN_A}", self._probe(ip_a, "echo-shared"))
-        self.assertEqual(f"200 AUTH=Bearer {_TOKEN_B}", self._probe(ip_b, "echo-shared"))
-
-        # Allowlist is per-bottle: echo-bonly is only in B's policy.
-        self.assertTrue(self._probe(ip_a, "echo-bonly").startswith("403"),  # fail-closed for A
-                        "A reached a host outside its allowlist")
-        self.assertEqual("200 AUTH=NONE", self._probe(ip_b, "echo-bonly"))  # allowed, unauthed for B
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/test_consolidated_compose.py

@@ -1,51 +0,0 @@
-"""Unit: agent-only consolidated compose render (PRD 0070)."""
-
-from __future__ import annotations
-
-import unittest
-
-from bot_bottle.backend.docker.consolidated_compose import consolidated_agent_compose
-from tests.unit.test_compose import _plan
-
-_GW = "172.18.0.2"
-_IP = "172.18.0.5"
-_NET = "bot-bottle-gateway"
-
-
-class TestConsolidatedAgentCompose(unittest.TestCase):
-    def _spec(self, *, runsc: bool = False):
-        plan = _plan(with_egress=True, supervise=True, with_git=True)
-        if runsc:
-            plan = type(plan)(**{**vars(plan), "use_runsc": True})  # type: ignore[arg-type]
-        return consolidated_agent_compose(plan, gateway_ip=_GW, source_ip=_IP, network=_NET)
-
-    def test_only_agent_service_no_sidecars(self) -> None:
-        # The whole point of consolidation: no per-bottle sidecar bundle.
-        self.assertEqual(["agent"], list(self._spec()["services"]))
-
-    def test_agent_pinned_on_external_gateway_network(self) -> None:
-        spec = self._spec()
-        self.assertEqual({"external": True}, spec["networks"][_NET])
-        agent_net = spec["services"]["agent"]["networks"][_NET]
-        self.assertEqual(_IP, agent_net["ipv4_address"])
-
-    def test_proxy_and_ca_point_at_gateway(self) -> None:
-        env = self._spec()["services"]["agent"]["environment"]
-        self.assertIn(f"HTTPS_PROXY=http://{_GW}:9099", env)
-        # git-http + supervise on the gateway must bypass the egress proxy.
-        self.assertTrue(any(e.startswith("NO_PROXY=") and _GW in e for e in env))
-
-    def test_no_sidecar_dependency(self) -> None:
-        self.assertNotIn("depends_on", self._spec()["services"]["agent"])
-
-    def test_runsc_runtime_when_enabled(self) -> None:
-        self.assertEqual("runsc", self._spec(runsc=True)["services"]["agent"]["runtime"])
-
-    def test_forwarded_env_stays_bare_names(self) -> None:
-        env = self._spec()["services"]["agent"]["environment"]
-        # forwarded secrets are bare names (value inherited from process env).
-        self.assertIn("CLAUDE_CODE_OAUTH_TOKEN", env)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/test_consolidated_launch.py

@@ -1,95 +0,0 @@
-"""Unit: consolidated launch sequence — compose the orchestrator primitives (PRD 0070)."""
-
-from __future__ import annotations
-
-import unittest
-from pathlib import Path
-from unittest.mock import MagicMock, Mock, patch
-
-from bot_bottle.backend.docker.consolidated_launch import (
-    launch_consolidated,
-    teardown_consolidated,
-)
-from bot_bottle.egress import EgressPlan, EgressRoute
-from bot_bottle.git_gate import GitGatePlan
-from bot_bottle.orchestrator.client import RegisteredBottle
-
-_MOD = "bot_bottle.backend.docker.consolidated_launch"
-
-
-def _egress_plan() -> EgressPlan:
-    return EgressPlan(
-        slug="demo", routes_path=Path("/x"), routes=(EgressRoute(host="api.example.com"),),
-        token_env_map={},
-    )
-
-
-def _git_plan() -> GitGatePlan:
-    return GitGatePlan(
-        slug="demo", entrypoint_script=Path(), hook_script=Path(),
-        access_hook_script=Path(), upstreams=(),
-    )
-
-
-def _client(*, bottles: list[dict[str, object]] | None = None) -> Mock:
-    c = Mock()
-    c.list_bottles.return_value = bottles or []
-    c.register_bottle.return_value = RegisteredBottle("b1", "tok")
-    return c
-
-
-class TestLaunchConsolidated(unittest.TestCase):
-    def _run(
-        self, client: Mock, provision: Mock | None = None,
-        *, on_network: tuple[str, ...] = ("172.18.0.2",),
-    ):
-        service = MagicMock()
-        service.ensure_running.return_value = "http://orch:8080"
-        with patch(f"{_MOD}._network_cidr", return_value="172.18.0.0/16"), \
-                patch(f"{_MOD}._container_ip", return_value="172.18.0.2"), \
-                patch(f"{_MOD}._network_container_ips", return_value=list(on_network)), \
-                patch(f"{_MOD}.OrchestratorClient", return_value=client), \
-                patch(f"{_MOD}.provision_git_gate", provision or Mock()):
-            return launch_consolidated(_egress_plan(), _git_plan(), service=service)
-
-    def test_allocates_ip_registers_and_provisions(self) -> None:
-        client = _client()
-        provision = Mock()
-        ctx = self._run(client, provision)
-        # .1 is the router, .2 is the gateway → first bottle gets .3.
-        self.assertEqual("172.18.0.3", ctx.source_ip)
-        self.assertEqual("172.18.0.2", ctx.gateway_ip)
-        self.assertEqual("b1", ctx.bottle_id)
-        self.assertEqual("tok", ctx.identity_token)
-        self.assertEqual("http://orch:8080", ctx.orchestrator_url)
-        # Registered with the source IP + the egress policy blob.
-        kwargs = client.register_bottle.call_args
-        self.assertEqual("172.18.0.3", kwargs.args[0])
-        self.assertIn("api.example.com", kwargs.kwargs["policy"])
-        provision.assert_called_once()
-
-    def test_skips_all_addresses_on_the_network(self) -> None:
-        # Gateway .2 + orchestrator .3 already attached -> agent gets .4.
-        ctx = self._run(_client(), on_network=("172.18.0.2", "172.18.0.3"))
-        self.assertEqual("172.18.0.4", ctx.source_ip)
-
-    def test_provision_failure_rolls_back_registration(self) -> None:
-        client = _client()
-        provision = Mock(side_effect=RuntimeError("provision boom"))
-        with self.assertRaises(RuntimeError):
-            self._run(client, provision)
-        client.teardown_bottle.assert_called_once_with("b1")  # no orphan left
-
-
-class TestTeardownConsolidated(unittest.TestCase):
-    def test_deregisters_and_deprovisions(self) -> None:
-        client = Mock()
-        with patch(f"{_MOD}.OrchestratorClient", return_value=client), \
-                patch(f"{_MOD}.deprovision_git_gate") as deprov:
-            teardown_consolidated("b1", orchestrator_url="http://orch:8080")
-        client.teardown_bottle.assert_called_once_with("b1")
-        deprov.assert_called_once()
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/test_docker_launch_committed_image.py

@@ -1,4 +1,4 @@
-"""Unit: Docker launch step uses committed image when available (consolidated)."""
+"""Unit: Docker launch step uses committed image when available."""
 
 from __future__ import annotations
 
@@ -6,7 +6,6 @@ import contextlib
 import io
 import tempfile
 import unittest
-from collections.abc import Callable, Generator
 from pathlib import Path
 from typing import Any
 from unittest import mock
@@ -15,11 +14,9 @@ from bot_bottle.agent_provider import AgentProvisionPlan
 from bot_bottle.backend import BottleSpec
 from bot_bottle.backend.docker import launch as launch_mod
 from bot_bottle.backend.docker.bottle_plan import DockerBottlePlan
-from bot_bottle.backend.docker.consolidated_launch import LaunchContext
 from bot_bottle.egress import EgressPlan
 from bot_bottle.git_gate import GitGatePlan
 from bot_bottle.manifest import ManifestIndex
-from tests.unit import use_bottle_root
 
 
 _SLUG = "dev-abc12"
@@ -31,112 +28,163 @@ _IDX = ManifestIndex.from_json_obj({
     "agents": {"demo": {"skills": [], "prompt": "", "bottle": "dev"}},
 })
 
-_CTX = LaunchContext(
-    bottle_id="b1", identity_token="t", source_ip="172.20.0.4",
-    network="bot-bottle-gateway", gateway_ip="172.20.0.2",
-    orchestrator_url="http://orch:8099",
-)
-
 
 def _plan(tmp: str) -> DockerBottlePlan:
     stage = Path(tmp)
     spec = BottleSpec(
-        manifest=_IDX, agent_name="demo", copy_cwd=False, user_cwd=tmp, identity=_SLUG,
+        manifest=_IDX,
+        agent_name="demo",
+        copy_cwd=False,
+        user_cwd=tmp,
+        identity=_SLUG,
     )
     return DockerBottlePlan(
         spec=spec,
         manifest=_IDX.load_for_agent("demo"),
         stage_dir=stage,
         git_gate_plan=GitGatePlan(
-            slug=_SLUG, entrypoint_script=stage / "e.sh", hook_script=stage / "h.sh",
-            access_hook_script=stage / "a.sh", upstreams=(),
+            slug=_SLUG,
+            entrypoint_script=stage / "entrypoint.sh",
+            hook_script=stage / "hook.sh",
+            access_hook_script=stage / "access-hook.sh",
+            upstreams=(),
         ),
         egress_plan=EgressPlan(
-            slug=_SLUG, routes_path=stage / "egress.yaml", routes=(), token_env_map={},
+            slug=_SLUG,
+            routes_path=stage / "egress.yaml",
+            routes=(),
+            token_env_map={},
         ),
         supervise_plan=None,
         agent_provision=AgentProvisionPlan(
-            template="claude", command="claude", prompt_mode="append_file",
-            image=_DEFAULT_IMAGE, dockerfile="", guest_home="/home/node",
-            instance_name=f"bot-bottle-{_SLUG}", prompt_file=stage / "prompt.txt",
+            template="claude",
+            command="claude",
+            prompt_mode="append_file",
+            image=_DEFAULT_IMAGE,
+            dockerfile="",
+            guest_home="/home/node",
+            instance_name=f"bot-bottle-{_SLUG}",
+            prompt_file=stage / "prompt.txt",
             guest_env={},
         ),
-        slug=_SLUG, forwarded_env={}, use_runsc=False,
+        slug=_SLUG,
+        forwarded_env={},
+        use_runsc=False,
     )
 
 
 class TestLaunchCommittedImage(unittest.TestCase):
     def setUp(self) -> None:
         self._tmp = tempfile.mkdtemp(prefix="launch-committed-test.")
-        self.addCleanup(lambda: __import__("shutil").rmtree(self._tmp, ignore_errors=True))
-        # The launch writes the gateway CA under the bottle root — sandbox it.
-        self.addCleanup(use_bottle_root(Path(self._tmp)))
 
-    @contextlib.contextmanager
-    def _patched(
+    def tearDown(self) -> None:
+        import shutil
+        shutil.rmtree(self._tmp, ignore_errors=True)
+
+    def _run_launch(
         self,
+        plan: DockerBottlePlan,
         *,
-        committed_tag: str | None,
-        image_present: bool,
-        compose: Callable[..., dict[str, Any]],
-    ) -> Generator[list[str], None, None]:
+        committed_tag: str | None = None,
+        image_present: bool = True,
+    ) -> list[str]:
+        """Drive launch() through its full sequence with the committed-image
+        behaviour controlled by the arguments. Returns the images that were
+        passed to `build_image` (empty list if it was never called)."""
         built: list[str] = []
-        gw = mock.Mock()
-        gw.ca_cert_pem.return_value = "-----BEGIN CERTIFICATE-----\nx\n-----END CERTIFICATE-----\n"
 
-        def _build(image: str, ctx: str, *, dockerfile: str = "") -> None:
+        def fake_build(image: str, ctx: str, *, dockerfile: str = "") -> None:
             del ctx, dockerfile
             built.append(image)
 
-        with mock.patch.object(launch_mod, "read_committed_image", return_value=committed_tag), \
-                mock.patch.object(launch_mod.docker_mod, "image_exists", return_value=image_present), \
-                mock.patch.object(launch_mod.docker_mod, "build_image", side_effect=_build), \
-                mock.patch.object(launch_mod.docker_mod, "verify_agent_image"), \
-                mock.patch.object(launch_mod, "launch_consolidated", return_value=_CTX), \
-                mock.patch.object(launch_mod, "teardown_consolidated"), \
-                mock.patch.object(launch_mod, "DockerGateway", return_value=gw), \
-                mock.patch.object(launch_mod, "consolidated_agent_compose", side_effect=compose), \
-                mock.patch.object(launch_mod, "write_compose_file", return_value=Path("/tmp/c.yml")), \
-                mock.patch.object(launch_mod, "compose_up"), \
-                mock.patch.object(launch_mod, "compose_dump_logs"), \
-                mock.patch.object(launch_mod, "compose_down"), \
-                contextlib.redirect_stderr(io.StringIO()):
-            yield built
-
-    def _run_launch(
-        self, plan: DockerBottlePlan, *,
-        committed_tag: str | None = None, image_present: bool = True,
-    ) -> list[str]:
-        def compose(_p: DockerBottlePlan, **_kw: Any) -> dict[str, Any]:
-            return {"services": {"agent": {}}}
-        with self._patched(
-            committed_tag=committed_tag, image_present=image_present, compose=compose,
-        ) as built:
-            with launch_mod.launch(plan, provision=mock.Mock(return_value=None)):
+        with mock.patch.object(
+            launch_mod, "read_committed_image", return_value=committed_tag,
+        ), mock.patch.object(
+            launch_mod.docker_mod, "image_exists", return_value=image_present,
+        ), mock.patch.object(
+            launch_mod.docker_mod, "build_image", side_effect=fake_build,
+        ), mock.patch.object(
+            launch_mod, "egress_tls_init",
+            return_value=(Path("/egress_ca"), Path("/egress_cert")),
+        ), mock.patch.object(
+            launch_mod.network_mod, "network_name_for_slug",
+            return_value="bb-internal",
+        ), mock.patch.object(
+            launch_mod.network_mod, "network_egress_name_for_slug",
+            return_value="bb-egress",
+        ), mock.patch.object(
+            launch_mod, "bottle_plan_to_compose",
+            return_value={"services": {"agent": {}}},
+        ), mock.patch.object(
+            launch_mod, "write_compose_file",
+            return_value=Path("/tmp/compose.yml"),
+        ), mock.patch.object(launch_mod, "compose_up"), \
+           mock.patch.object(launch_mod, "compose_dump_logs"), \
+           mock.patch.object(launch_mod, "compose_down"), \
+           contextlib.redirect_stderr(io.StringIO()):
+            provision = mock.Mock(return_value=None)
+            with launch_mod.launch(plan, provision=provision):
                 pass
+
         return built
 
     def test_skips_build_when_committed_image_present(self) -> None:
-        built = self._run_launch(_plan(self._tmp), committed_tag=_COMMITTED_TAG, image_present=True)
-        self.assertEqual([], built)  # committed image reused, no build
+        plan = _plan(self._tmp)
+        built = self._run_launch(plan, committed_tag=_COMMITTED_TAG, image_present=True)
+        self.assertEqual([], built, "build_image should not be called when committed image exists")
 
     def test_uses_committed_image_in_compose_spec(self) -> None:
-        captured: list[DockerBottlePlan] = []
+        """The compose spec renderer receives the committed image tag via
+        plan.image — captured here by checking what bottle_plan_to_compose
+        was called with."""
+        plan = _plan(self._tmp)
+        captured_plans: list[DockerBottlePlan] = []
 
-        def compose(p: DockerBottlePlan, **_kw: Any) -> dict[str, Any]:
-            captured.append(p)
+        def fake_compose(p: DockerBottlePlan) -> dict[str, Any]:
+            captured_plans.append(p)
             return {"services": {"agent": {}}}
 
-        with self._patched(committed_tag=_COMMITTED_TAG, image_present=True, compose=compose):
-            with launch_mod.launch(_plan(self._tmp), provision=mock.Mock(return_value=None)):
+        with mock.patch.object(
+            launch_mod, "read_committed_image", return_value=_COMMITTED_TAG,
+        ), mock.patch.object(
+            launch_mod.docker_mod, "image_exists", return_value=True,
+        ), mock.patch.object(
+            launch_mod.docker_mod, "build_image",
+        ), mock.patch.object(
+            launch_mod, "egress_tls_init",
+            return_value=(Path("/egress_ca"), Path("/egress_cert")),
+        ), mock.patch.object(
+            launch_mod.network_mod, "network_name_for_slug",
+            return_value="bb-internal",
+        ), mock.patch.object(
+            launch_mod.network_mod, "network_egress_name_for_slug",
+            return_value="bb-egress",
+        ), mock.patch.object(
+            launch_mod, "bottle_plan_to_compose", side_effect=fake_compose,
+        ), mock.patch.object(
+            launch_mod, "write_compose_file",
+            return_value=Path("/tmp/compose.yml"),
+        ), mock.patch.object(launch_mod, "compose_up"), \
+           mock.patch.object(launch_mod, "compose_dump_logs"), \
+           mock.patch.object(launch_mod, "compose_down"), \
+           contextlib.redirect_stderr(io.StringIO()):
+            provision = mock.Mock(return_value=None)
+            with launch_mod.launch(plan, provision=provision):
                 pass
-        self.assertEqual(_COMMITTED_TAG, captured[0].image)
+
+        self.assertEqual(1, len(captured_plans))
+        self.assertEqual(_COMMITTED_TAG, captured_plans[0].image)
 
     def test_falls_back_to_build_when_no_committed_image(self) -> None:
-        self.assertEqual([_DEFAULT_IMAGE], self._run_launch(_plan(self._tmp), committed_tag=None))
+        plan = _plan(self._tmp)
+        built = self._run_launch(plan, committed_tag=None)
+        self.assertEqual([_DEFAULT_IMAGE], built)
 
     def test_falls_back_to_build_when_committed_image_missing_from_daemon(self) -> None:
-        built = self._run_launch(_plan(self._tmp), committed_tag=_COMMITTED_TAG, image_present=False)
+        plan = _plan(self._tmp)
+        built = self._run_launch(
+            plan, committed_tag=_COMMITTED_TAG, image_present=False,
+        )
         self.assertEqual([_DEFAULT_IMAGE], built)
 
 

tests/unit/test_docker_launch_teardown.py

@@ -19,11 +19,9 @@ from bot_bottle.agent_provider import AgentProvisionPlan
 from bot_bottle.backend import BottleSpec
 from bot_bottle.backend.docker import launch as launch_mod
 from bot_bottle.backend.docker.bottle_plan import DockerBottlePlan
-from bot_bottle.backend.docker.consolidated_launch import LaunchContext
 from bot_bottle.egress import EgressPlan
 from bot_bottle.git_gate import GitGatePlan
 from bot_bottle.manifest import ManifestIndex
-from tests.unit import use_bottle_root
 
 _INDEX = ManifestIndex.from_json_obj({
     "bottles": {"dev": {}},
@@ -79,37 +77,41 @@ def _plan(tmp: str) -> DockerBottlePlan:
 class TestTeardownWarning(unittest.TestCase):
     def setUp(self) -> None:
         self._tmp = tempfile.mkdtemp(prefix="docker-launch-teardown-test.")
-        self.addCleanup(lambda: __import__("shutil").rmtree(self._tmp, ignore_errors=True))
-        self.addCleanup(use_bottle_root(Path(self._tmp)))  # sandbox the gateway CA write
+
+    def tearDown(self) -> None:
+        import shutil
+        shutil.rmtree(self._tmp, ignore_errors=True)
 
     def test_teardown_failure_emits_warning_with_container_and_operation(self):
         plan = _plan(self._tmp)
         buf = io.StringIO()
-        gw = mock.Mock()
-        gw.ca_cert_pem.return_value = "-----BEGIN CERTIFICATE-----\nx\n-----END CERTIFICATE-----\n"
-        ctx = LaunchContext(
-            bottle_id="b1", identity_token="t", source_ip="172.20.0.4",
-            network="bot-bottle-gateway", gateway_ip="172.20.0.2",
-            orchestrator_url="http://orch:8099",
-        )
 
         with mock.patch.object(launch_mod.docker_mod, "build_image"), \
-             mock.patch.object(launch_mod.docker_mod, "verify_agent_image"), \
-             mock.patch.object(launch_mod, "launch_consolidated", return_value=ctx), \
-             mock.patch.object(launch_mod, "teardown_consolidated"), \
-             mock.patch.object(launch_mod, "DockerGateway", return_value=gw), \
              mock.patch.object(
-                 launch_mod, "consolidated_agent_compose",
+                 launch_mod, "egress_tls_init",
+                 return_value=(Path("/egress_ca"), Path("/egress_cert")),
+             ), \
+             mock.patch.object(
+                 launch_mod.network_mod, "network_name_for_slug",
+                 return_value="bb-internal-test",
+             ), \
+             mock.patch.object(
+                 launch_mod.network_mod, "network_egress_name_for_slug",
+                 return_value="bb-egress-test",
+             ), \
+             mock.patch.object(
+                 launch_mod, "bottle_plan_to_compose",
                  return_value={"services": {"agent": {}}},
              ), \
              mock.patch.object(
-                 launch_mod, "write_compose_file", return_value=Path("/tmp/compose.yml"),
+                 launch_mod, "write_compose_file",
+                 return_value=Path("/tmp/compose.yml"),
              ), \
              mock.patch.object(launch_mod, "compose_up"), \
              mock.patch.object(launch_mod, "compose_dump_logs"), \
              mock.patch.object(
                  launch_mod, "compose_down",
-                 side_effect=RuntimeError("compose down failed"),
+                 side_effect=RuntimeError("network remove failed"),
              ), \
              contextlib.redirect_stderr(buf):
             provision = mock.Mock(return_value=None)

tests/unit/test_egress_addon_request_flow.py

@@ -233,19 +233,16 @@ class _CtxResolver:
     """Fake orchestrator resolver: maps source IP -> bottle id, and grants the
     same allow-list to any attributed bottle (unattributed -> deny)."""
 
-    def __init__(
-        self, ip_to_bottle: dict[str, str], tokens: dict[str, str] | None = None,
-    ) -> None:
+    def __init__(self, ip_to_bottle: dict[str, str]) -> None:
         self._map = ip_to_bottle
-        self._tokens = tokens or {}
 
     def resolve_policy_and_bottle_id(
         self, source_ip: str, identity_token: str = "",
-    ) -> tuple[str | None, str | None, dict[str, str]]:
+    ) -> tuple[str | None, str | None]:
         del identity_token
         bottle_id = self._map.get(source_ip)
         policy = "routes:\n  - host: api.example.com\n" if bottle_id else None
-        return policy, bottle_id, (self._tokens if bottle_id else {})
+        return policy, bottle_id
 
 
 # ---------------------------------------------------------------------------
@@ -806,46 +803,6 @@ class TestSuperviseMultiTenant(unittest.TestCase):
             _run_request(addon, flow)
         self.assertEqual(["bottle-b"], seen)  # proposal keyed by the resolved bottle
 
-    def test_auth_token_injected_from_resolved_tokens(self) -> None:
-        # The bottle's upstream token comes from /resolve (in-memory on the
-        # orchestrator), NOT the gateway's env — the request is forwarded with
-        # Authorization injected. This is the token-injection cut-over fix.
-        policy = (
-            'routes:\n  - host: api.example.com\n'
-            '    auth_scheme: "Bearer"\n    token_env: "EGRESS_TOKEN_0"\n'
-        )
-
-        class _AuthResolver:
-            def resolve_policy_and_bottle_id(self, ip: str, identity_token: str = ""):
-                del ip, identity_token
-                return policy, "bottle-a", {"EGRESS_TOKEN_0": "sk-secret"}
-
-        addon = _addon(Config(routes=()))
-        addon._resolver = cast(Any, _AuthResolver())
-        flow = _with_client_ip(_Flow(_Request(host="api.example.com", method="GET")), "10.0.0.1")
-        _run_request(addon, flow)
-        self.assertIsNone(flow.response)  # forwarded, not blocked
-        self.assertEqual("Bearer sk-secret", flow.request.headers.get("authorization"))
-
-    def test_authed_route_without_token_is_blocked(self) -> None:
-        # No token resolved for the bottle → the authed route can't inject, so
-        # the request is blocked (the error the cut-over originally produced).
-        policy = (
-            'routes:\n  - host: api.example.com\n'
-            '    auth_scheme: "Bearer"\n    token_env: "EGRESS_TOKEN_0"\n'
-        )
-
-        class _NoTokenResolver:
-            def resolve_policy_and_bottle_id(self, ip: str, identity_token: str = ""):
-                del ip, identity_token
-                return policy, "bottle-a", {}  # no tokens
-
-        addon = _addon(Config(routes=()))
-        addon._resolver = cast(Any, _NoTokenResolver())
-        flow = _with_client_ip(_Flow(_Request(host="api.example.com", method="GET")), "10.0.0.1")
-        _run_request(addon, flow)
-        self.assertIsNotNone(flow.response)  # blocked — token unset
-
     def test_unattributed_source_ip_cannot_supervise(self) -> None:
         addon = self._consolidated_addon()
         # 10.9.9.9 is not in the resolver map -> deny-all config, empty slug.

tests/unit/test_egress_multitenant.py

@@ -51,55 +51,45 @@ class TestResolveClientConfig(unittest.TestCase):
 
 class _FakeContextResolver:
     def __init__(
-        self, policy: str | None = None, bottle_id: str | None = None,
-        raises: bool = False, tokens: dict[str, str] | None = None,
+        self, policy: str | None = None, bottle_id: str | None = None, raises: bool = False,
     ) -> None:
         self._policy = policy
         self._bottle_id = bottle_id
         self._raises = raises
-        self._tokens = tokens or {}
 
     def resolve_policy_and_bottle_id(
         self, source_ip: str, identity_token: str = "",
-    ) -> tuple[str | None, str | None, dict[str, str]]:
+    ) -> tuple[str | None, str | None]:
         if self._raises:
             raise PolicyResolveError("orchestrator down")
-        return self._policy, self._bottle_id, self._tokens
+        return self._policy, self._bottle_id
 
 
 class TestResolveClientContext(unittest.TestCase):
-    def test_returns_config_bottle_id_and_tokens(self) -> None:
-        cfg, slug, tokens = resolve_client_context(
-            _FakeContextResolver(
-                policy="routes:\n  - host: example.com\n", bottle_id="b1",
-                tokens={"EGRESS_TOKEN_0": "sekret"},
-            ),
+    def test_returns_config_and_bottle_id(self) -> None:
+        cfg, slug = resolve_client_context(
+            _FakeContextResolver(policy="routes:\n  - host: example.com\n", bottle_id="b1"),
             "10.243.0.1",
         )
         self.assertEqual(("example.com",), tuple(r.host for r in cfg.routes))
         self.assertEqual("b1", slug)
-        self.assertEqual({"EGRESS_TOKEN_0": "sekret"}, tokens)  # for auth injection
 
     def test_unattributed_denies_and_empty_slug(self) -> None:
-        cfg, slug, tokens = resolve_client_context(
+        cfg, slug = resolve_client_context(
             _FakeContextResolver(policy=None, bottle_id=None), "10.243.0.9",
         )
         self.assertEqual((), cfg.routes)
         self.assertEqual("", slug)  # no bottle → supervise unavailable
-        self.assertEqual({}, tokens)
 
-    def test_resolver_error_denies_empty_slug_no_tokens(self) -> None:
-        cfg, slug, tokens = resolve_client_context(
-            _FakeContextResolver(raises=True), "10.243.0.1",
-        )
+    def test_resolver_error_denies_and_empty_slug(self) -> None:
+        cfg, slug = resolve_client_context(_FakeContextResolver(raises=True), "10.243.0.1")
         self.assertEqual((), cfg.routes)
         self.assertEqual("", slug)
-        self.assertEqual({}, tokens)
 
     def test_unparseable_policy_denies_but_keeps_slug(self) -> None:
         # A bad policy denies egress, but the bottle is still attributed (its
         # supervise queue is keyed by the id, independent of route parsing).
-        cfg, slug, _tokens = resolve_client_context(
+        cfg, slug = resolve_client_context(
             _FakeContextResolver(policy="routes: notalist\n", bottle_id="b2"), "10.243.0.1",
         )
         self.assertEqual((), cfg.routes)

tests/unit/test_gateway_net.py

@@ -1,42 +0,0 @@
-"""Unit: shared-gateway source-IP allocation (PRD 0070)."""
-
-from __future__ import annotations
-
-import unittest
-
-from bot_bottle.backend.docker.gateway_net import NoFreeAddressError, next_free_ip
-
-
-class TestNextFreeIp(unittest.TestCase):
-    def test_skips_router_and_returns_first_host(self) -> None:
-        # .1 is docker's router; the first assignable address is .2.
-        self.assertEqual("172.18.0.2", next_free_ip("172.18.0.0/16", []))
-
-    def test_skips_taken_addresses(self) -> None:
-        # Gateway container holds .2, a live bottle holds .3 -> next is .4.
-        self.assertEqual(
-            "172.18.0.4", next_free_ip("172.18.0.0/16", ["172.18.0.2", "172.18.0.3"]),
-        )
-
-    def test_taken_order_does_not_matter(self) -> None:
-        self.assertEqual(
-            "172.18.0.2", next_free_ip("172.18.0.0/16", ["172.18.0.3", "172.18.0.5"]),
-        )
-
-    def test_allocation_is_deterministic(self) -> None:
-        taken = ["172.18.0.2"]
-        self.assertEqual(next_free_ip("172.18.0.0/16", taken),
-                         next_free_ip("172.18.0.0/16", taken))
-
-    def test_raises_when_subnet_exhausted(self) -> None:
-        # /30: hosts are .1 (router, reserved) and .2; taking .2 leaves none.
-        with self.assertRaises(NoFreeAddressError):
-            next_free_ip("10.9.9.0/30", ["10.9.9.2"])
-
-    def test_accepts_host_bits_set_cidr(self) -> None:
-        # A container's inspected address arrives as e.g. 172.18.0.2/16.
-        self.assertEqual("172.18.0.2", next_free_ip("172.18.0.5/16", []))
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/test_gateway_provision.py

@@ -1,113 +0,0 @@
-"""Unit: git-gate provisioning into the running shared gateway (PRD 0070)."""
-
-from __future__ import annotations
-
-import unittest
-from pathlib import Path
-from unittest.mock import Mock, patch
-
-from bot_bottle.backend.docker.gateway_provision import (
-    GatewayProvisionError,
-    deprovision_git_gate,
-    provision_git_gate,
-)
-from bot_bottle.git_gate import GitGatePlan, GitGateUpstream
-
-_RUN = "bot_bottle.backend.docker.gateway_provision.run_docker"
-
-
-def _proc(returncode: int = 0, stderr: str = "") -> Mock:
-    return Mock(returncode=returncode, stderr=stderr)
-
-
-def _recorder(calls: list[list[str]]):
-    """A run_docker side_effect that records argv and returns success."""
-    def fake(argv: list[str]) -> Mock:
-        calls.append(argv)
-        return _proc()
-    return fake
-
-
-def _plan(*upstreams: GitGateUpstream) -> GitGatePlan:
-    return GitGatePlan(
-        slug="demo",
-        entrypoint_script=Path("/stage/entrypoint.sh"),
-        hook_script=Path("/stage/pre-receive"),
-        access_hook_script=Path("/stage/access-hook"),
-        upstreams=tuple(upstreams),
-    )
-
-
-def _up(name: str, *, key: str = "/host/keys/id", known_hosts: str = "") -> GitGateUpstream:
-    return GitGateUpstream(
-        name=name,
-        upstream_url=f"ssh://git@github.com/x/{name}.git",
-        upstream_host="github.com",
-        upstream_port="22",
-        identity_file=key,
-        known_host_key="",
-        known_hosts_file=Path(known_hosts) if known_hosts else Path(),
-    )
-
-
-class TestProvisionGitGate(unittest.TestCase):
-    def test_copies_creds_and_runs_namespaced_init(self) -> None:
-        calls: list[list[str]] = []
-        with patch(_RUN, side_effect=_recorder(calls)):
-            provision_git_gate("gw", "bottle1", _plan(_up("foo", known_hosts="/host/kh")))
-
-        cps = [c for c in calls if c[:2] == ["docker", "cp"]]
-        self.assertIn(["docker", "cp", "/host/keys/id", "gw:/git-gate/creds/bottle1/foo-key"], cps)
-        self.assertIn(
-            ["docker", "cp", "/host/kh", "gw:/git-gate/creds/bottle1/foo-known_hosts"], cps,
-        )
-        # The shared (bottle-agnostic) hooks are installed into the gateway.
-        self.assertIn(["docker", "cp", "/stage/pre-receive", "gw:/etc/git-gate/pre-receive"], cps)
-        # The init script runs in the gateway, namespaced under the bottle id.
-        exec_scripts = [c for c in calls if c[:3] == ["docker", "exec", "gw"] and c[3] == "sh"]
-        self.assertEqual(1, len(exec_scripts))
-        self.assertIn("repo=/git/bottle1/${name}.git", exec_scripts[0][-1])
-
-    def test_omits_known_hosts_copy_when_absent(self) -> None:
-        calls: list[list[str]] = []
-        with patch(_RUN, side_effect=_recorder(calls)):
-            provision_git_gate("gw", "b1", _plan(_up("foo")))  # no known_hosts
-        creds_cps = [c for c in calls if c[:2] == ["docker", "cp"] and "/git-gate/creds/" in c[3]]
-        self.assertEqual(1, len(creds_cps))  # only the key, not known_hosts
-        self.assertTrue(creds_cps[0][3].endswith("/foo-key"))
-
-    def test_no_upstreams_is_noop(self) -> None:
-        with patch(_RUN) as m:
-            provision_git_gate("gw", "b1", _plan())
-        m.assert_not_called()
-
-    def test_raises_on_docker_failure(self) -> None:
-        with patch(_RUN, return_value=_proc(returncode=1, stderr="boom")):
-            with self.assertRaises(GatewayProvisionError):
-                provision_git_gate("gw", "b1", _plan(_up("foo")))
-
-    def test_rejects_unsafe_bottle_id_before_any_docker(self) -> None:
-        with patch(_RUN) as m:
-            with self.assertRaises(GatewayProvisionError):
-                provision_git_gate("gw", "../etc", _plan(_up("foo")))
-        m.assert_not_called()  # rejected before a single docker call
-
-
-class TestDeprovision(unittest.TestCase):
-    def test_removes_repo_and_creds(self) -> None:
-        with patch(_RUN, return_value=_proc()) as m:
-            deprovision_git_gate("gw", "b1")
-        argv = m.call_args.args[0]
-        self.assertEqual(["docker", "exec", "gw", "rm", "-rf"], argv[:5])
-        self.assertIn("/git/b1", argv)
-        self.assertIn("/git-gate/creds/b1", argv)
-
-    def test_rejects_unsafe_bottle_id(self) -> None:
-        with patch(_RUN) as m:
-            with self.assertRaises(GatewayProvisionError):
-                deprovision_git_gate("gw", "a/b")
-        m.assert_not_called()
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/test_git_gate_provision_render.py

@@ -1,67 +0,0 @@
-"""Unit: consolidated per-bottle git-gate provisioning render (PRD 0070)."""
-
-from __future__ import annotations
-
-import unittest
-
-from bot_bottle.git_gate_render import (
-    GitGateUpstream,
-    git_gate_render_entrypoint,
-    git_gate_render_provision,
-)
-
-
-def _ups(*names: str) -> tuple[GitGateUpstream, ...]:
-    return tuple(
-        GitGateUpstream(
-            name=n,
-            upstream_url=f"ssh://git@github.com/x/{n}.git",
-            upstream_host="github.com",
-            upstream_port="22",
-            identity_file="",
-            known_host_key="",
-        )
-        for n in names
-    )
-
-
-class TestProvisionRender(unittest.TestCase):
-    def test_namespaces_repos_and_creds_by_bottle_id(self) -> None:
-        script = git_gate_render_provision("bottleab12", _ups("foo"))
-        self.assertIn("repo=/git/bottleab12/${name}.git", script)
-        self.assertIn("keyfile=/git-gate/creds/bottleab12/${name}-key", script)
-        self.assertIn("mkdir -p /git/bottleab12", script)
-
-    def test_one_init_repo_call_per_upstream(self) -> None:
-        script = git_gate_render_provision("b1", _ups("foo", "bar"))
-        calls = [l for l in script.splitlines() if l.startswith("init_repo ")]
-        self.assertEqual(2, len(calls))
-
-    def test_provision_does_not_start_the_daemon(self) -> None:
-        # The shared gateway already serves; provisioning is init-only.
-        self.assertNotIn("git daemon", git_gate_render_provision("b1", _ups("foo")))
-
-    def test_installs_pre_receive_hook(self) -> None:
-        script = git_gate_render_provision("b1", _ups("foo"))
-        self.assertIn("install -m 755 /etc/git-gate/pre-receive", script)
-
-    def test_rejects_unsafe_bottle_id(self) -> None:
-        for bad in ("../etc", "a/b", "a b", "a;rm", ""):
-            with self.assertRaises(ValueError):
-                git_gate_render_provision(bad, _ups("foo"))
-
-
-class TestEntrypointUnchanged(unittest.TestCase):
-    """The shared `_git_gate_init_repo_fn` refactor must not alter the
-    single-tenant daemon entrypoint's output."""
-
-    def test_entrypoint_still_single_tenant_flat(self) -> None:
-        script = git_gate_render_entrypoint(_ups("foo"))
-        self.assertIn("repo=/git/${name}.git", script)      # flat, not namespaced
-        self.assertIn("keyfile=/git-gate/creds/${name}-key", script)
-        self.assertIn("--base-path=/git", script)
-        self.assertIn("exec git daemon", script)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/test_git_http_backend.py

@@ -13,17 +13,6 @@ from bot_bottle.git_gate import GIT_GATE_TIMEOUT_SECS
 from bot_bottle.git_http_backend import GitHttpHandler, MAX_BODY_BYTES
 
 
-class _FixedResolver:
-    """Maps every source IP to one bottle id (consolidated-mode stub)."""
-
-    def __init__(self, bottle_id: str) -> None:
-        self._bottle_id = bottle_id
-
-    def resolve_bottle_id(self, source_ip: str, identity_token: str = "") -> str:
-        del source_ip, identity_token
-        return self._bottle_id
-
-
 class TestGitHttpBackend(unittest.TestCase):
     def test_real_git_push_reaches_bare_repo(self):
         from http.server import ThreadingHTTPServer
@@ -105,62 +94,6 @@ class TestGitHttpBackend(unittest.TestCase):
             ).strip()
             self.assertEqual(head, cloned)
 
-    def test_consolidated_push_stamps_bottle_slug_for_the_hook(self):
-        # In consolidated mode the backend attributes the push by source IP and
-        # stamps SUPERVISE_BOTTLE_SLUG=<bottle_id> into the CGI env, so the
-        # gitleaks-allow pre-receive hook queues its proposal under the right
-        # bottle. The hook here just records what it received.
-        from http.server import ThreadingHTTPServer
-
-        bottle_id = "bottleab12"
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            bare = root / bottle_id / "repo.git"  # namespaced per bottle (slice 10)
-            bare.parent.mkdir(parents=True)
-            subprocess.run(["git", "init", "--bare", str(bare)],
-                           check=True, capture_output=True, text=True)
-            subprocess.run(
-                ["git", "-C", str(bare), "config", "http.receivepack", "true"],
-                check=True,
-            )
-            capture = root / "slug-capture"
-            hook = bare / "hooks" / "pre-receive"
-            hook.write_text(
-                f"#!/bin/sh\nprintf '%s' \"${{SUPERVISE_BOTTLE_SLUG:-UNSET}}\" > "
-                f"{capture}\ncat >/dev/null\nexit 0\n"
-            )
-            hook.chmod(0o755)
-
-            old_root = os.environ.get("GIT_PROJECT_ROOT")
-            os.environ["GIT_PROJECT_ROOT"] = str(root)  # base; backend nests per bottle
-            self.addCleanup(self._restore_env, old_root)
-
-            server = ThreadingHTTPServer(("127.0.0.1", 0), GitHttpHandler)
-            server.policy_resolver = _FixedResolver(bottle_id)  # type: ignore[attr-defined]
-            thread = threading.Thread(target=server.serve_forever, daemon=True)
-            thread.start()
-            self.addCleanup(server.shutdown)
-            self.addCleanup(server.server_close)
-
-            work = root / "work"
-            work.mkdir()
-            subprocess.run(["git", "init"], cwd=work, check=True,
-                           capture_output=True, text=True)
-            subprocess.run(["git", "config", "user.name", "test"], cwd=work, check=True)
-            subprocess.run(["git", "config", "user.email", "t@example.invalid"],
-                           cwd=work, check=True)
-            (work / "README.md").write_text("test\n")
-            subprocess.run(["git", "add", "README.md"], cwd=work, check=True)
-            subprocess.run(["git", "commit", "-m", "init"], cwd=work,
-                           check=True, capture_output=True, text=True)
-
-            url = f"http://127.0.0.1:{server.server_port}/repo.git"
-            subprocess.run(
-                ["git", "push", url, "HEAD:refs/heads/main"],
-                cwd=work, check=True, capture_output=True, text=True, timeout=5,
-            )
-            self.assertEqual(bottle_id, capture.read_text())
-
     def test_post_forwards_git_cgi_headers(self):
         from http.server import ThreadingHTTPServer
 

tests/unit/test_macos_container_launch.py

@@ -357,17 +357,12 @@ class TestMacosContainerLaunchCommittedImage(unittest.TestCase):
             launch.container_mod, "image_exists", return_value=False,
         ), patch.object(
             launch.container_mod, "build_image", side_effect=fake_build,
-        ), patch.object(
-            launch.container_mod, "verify_agent_image",
-        ) as verify:
+        ):
             updated = launch._build_images(plan)
 
         self.assertEqual("bot-bottle-agent:latest", updated.image)
         self.assertEqual(2, len(calls))
         self.assertEqual("bot-bottle-agent:latest", calls[1][0])
-        verify.assert_called_once_with(
-            "bot-bottle-agent:latest", ("claude", "--version"),
-        )
 
 
 if __name__ == "__main__":

tests/unit/test_orchestrator_client.py

@@ -1,106 +0,0 @@
-"""Unit: host-side orchestrator control-plane client (PRD 0070). HTTP mocked."""
-
-from __future__ import annotations
-
-import json
-import unittest
-import urllib.error
-from unittest.mock import MagicMock, patch
-
-from bot_bottle.orchestrator.client import (
-    OrchestratorClient,
-    OrchestratorClientError,
-    RegisteredBottle,
-)
-
-_URLOPEN = "bot_bottle.orchestrator.client.urllib.request.urlopen"
-
-
-def _resp(status: int, payload: object) -> MagicMock:
-    m = MagicMock()
-    inner = m.__enter__.return_value
-    inner.status = status
-    inner.read.return_value = json.dumps(payload).encode()
-    return m
-
-
-def _http_error(code: int, payload: object = None) -> urllib.error.HTTPError:
-    del payload  # the client tolerates an empty error body; keep the signature
-    return urllib.error.HTTPError("http://x", code, "err", {}, None)  # type: ignore[arg-type]
-
-
-class TestRegister(unittest.TestCase):
-    def setUp(self) -> None:
-        self.c = OrchestratorClient("http://orch:8080")
-
-    def test_register_returns_id_and_token(self) -> None:
-        with patch(_URLOPEN, return_value=_resp(201, {"bottle_id": "b1", "identity_token": "tok"})):
-            got = self.c.register_bottle("10.0.0.2", policy="routes: []\n", metadata="{}")
-        self.assertEqual(RegisteredBottle("b1", "tok"), got)
-
-    def test_register_posts_source_ip_and_policy(self) -> None:
-        with patch(_URLOPEN, return_value=_resp(201, {"bottle_id": "b", "identity_token": "t"})) as m:
-            self.c.register_bottle("10.0.0.9", policy="P", metadata="M", image_ref="img")
-        sent = json.loads(m.call_args.args[0].data)
-        self.assertEqual("10.0.0.9", sent["source_ip"])
-        self.assertEqual("P", sent["policy"])
-        self.assertEqual("img", sent["image_ref"])
-
-    def test_register_missing_fields_raises(self) -> None:
-        with patch(_URLOPEN, return_value=_resp(201, {"bottle_id": "b1"})):
-            with self.assertRaises(OrchestratorClientError):
-                self.c.register_bottle("10.0.0.2")
-
-    def test_register_non_2xx_raises(self) -> None:
-        with patch(_URLOPEN, side_effect=_http_error(400, {"error": "bad"})):
-            with self.assertRaises(OrchestratorClientError):
-                self.c.register_bottle("")
-
-
-class TestTeardown(unittest.TestCase):
-    def setUp(self) -> None:
-        self.c = OrchestratorClient("http://orch:8080")
-
-    def test_teardown_true_on_success(self) -> None:
-        with patch(_URLOPEN, return_value=_resp(200, {"torn_down": True})):
-            self.assertTrue(self.c.teardown_bottle("b1"))
-
-    def test_teardown_false_on_404(self) -> None:
-        # Idempotent: an already-gone bottle is a clean no-op.
-        with patch(_URLOPEN, side_effect=_http_error(404)):
-            self.assertFalse(self.c.teardown_bottle("gone"))
-
-    def test_teardown_uses_delete(self) -> None:
-        with patch(_URLOPEN, return_value=_resp(200, {"torn_down": True})) as m:
-            self.c.teardown_bottle("b1")
-        self.assertEqual("DELETE", m.call_args.args[0].get_method())
-
-
-class TestHealthAndPolicy(unittest.TestCase):
-    def setUp(self) -> None:
-        self.c = OrchestratorClient("http://orch:8080")
-
-    def test_health_true_on_200(self) -> None:
-        with patch(_URLOPEN, return_value=_resp(200, {"status": "ok"})):
-            self.assertTrue(self.c.health())
-
-    def test_health_false_when_unreachable(self) -> None:
-        with patch(_URLOPEN, side_effect=urllib.error.URLError("refused")):
-            self.assertFalse(self.c.health())
-
-    def test_set_policy_false_on_404(self) -> None:
-        with patch(_URLOPEN, side_effect=_http_error(404)):
-            self.assertFalse(self.c.set_policy("gone", "P"))
-
-    def test_set_policy_true_on_success(self) -> None:
-        with patch(_URLOPEN, return_value=_resp(200, {"updated": True})):
-            self.assertTrue(self.c.set_policy("b1", "P"))
-
-    def test_unreachable_raises(self) -> None:
-        with patch(_URLOPEN, side_effect=urllib.error.URLError("refused")):
-            with self.assertRaises(OrchestratorClientError):
-                self.c.register_bottle("10.0.0.2")
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/test_orchestrator_gateway.py

@@ -6,15 +6,11 @@ import unittest
 from unittest.mock import Mock, patch
 
 from bot_bottle.orchestrator.gateway import (
-    GATEWAY_CA_CERT,
     GATEWAY_NAME,
     DockerGateway,
     GatewayError,
 )
 
-
-_CA_PEM = "-----BEGIN CERTIFICATE-----\nMII...\n-----END CERTIFICATE-----\n"
-
 _RUN_DOCKER = "bot_bottle.orchestrator.gateway.run_docker"
 
 
@@ -35,43 +31,11 @@ class TestDockerGateway(unittest.TestCase):
         with patch(_RUN_DOCKER, return_value=_proc(stdout="")):
             self.assertFalse(self.sc.is_running())
 
-    def test_ensure_running_noop_when_up_and_image_current(self) -> None:
-        calls: list[list[str]] = []
-
-        def fake(argv: list[str]) -> Mock:
-            calls.append(argv)
-            if argv[:2] == ["docker", "ps"]:
-                return _proc(stdout=self.sc.name)          # running
-            if argv[:3] == ["docker", "image", "inspect"]:
-                return _proc(stdout="img-A")               # current image id
-            if argv[:2] == ["docker", "inspect"]:
-                return _proc(stdout="img-A")               # container's image (same)
-            return _proc()
-
-        with patch(_RUN_DOCKER, side_effect=fake):
+    def test_ensure_running_is_noop_when_already_up(self) -> None:
+        with patch(_RUN_DOCKER, return_value=_proc(stdout=self.sc.name)) as m:
             self.sc.ensure_running()
-        self.assertEqual([], [c for c in calls if c[:2] == ["docker", "run"]])
-        self.assertEqual([], [c for c in calls if c[:2] == ["docker", "rm"]])
-
-    def test_ensure_running_recreates_when_image_is_stale(self) -> None:
-        # Running, but the container was built from an OLD image → recreate so
-        # a rebuild's new flat daemons take effect.
-        calls: list[list[str]] = []
-
-        def fake(argv: list[str]) -> Mock:
-            calls.append(argv)
-            if argv[:2] == ["docker", "ps"]:
-                return _proc(stdout=self.sc.name)
-            if argv[:3] == ["docker", "image", "inspect"]:
-                return _proc(stdout="img-NEW")
-            if argv[:2] == ["docker", "inspect"]:
-                return _proc(stdout="img-OLD")
-            return _proc()
-
-        with patch(_RUN_DOCKER, side_effect=fake):
-            self.sc.ensure_running()
-        self.assertEqual(1, len([c for c in calls if c[:2] == ["docker", "run"]]))
-        self.assertTrue(any(c[:2] == ["docker", "rm"] for c in calls))
+        # Only the is_running() ps probe — no rm / run.
+        self.assertEqual(1, m.call_count)
 
     def test_ensure_running_starts_the_singleton_when_absent(self) -> None:
         calls: list[list[str]] = []
@@ -87,54 +51,6 @@ class TestDockerGateway(unittest.TestCase):
         self.assertEqual(1, len(runs))
         self.assertIn(self.sc.name, runs[0])
         self.assertIn("bot-bottle-sidecars:latest", runs[0])
-        # Runs on the shared gateway network so agents can reach it by IP.
-        self.assertEqual(self.sc.network, runs[0][runs[0].index("--network") + 1])
-        # Persists its CA on a named volume so agents keep trusting it.
-        self.assertTrue(any("mitmproxy" in a for a in runs[0]))
-
-    def test_ensure_running_creates_network_when_missing(self) -> None:
-        calls: list[list[str]] = []
-
-        def fake(argv: list[str]) -> Mock:
-            calls.append(argv)
-            if argv[:3] == ["docker", "network", "inspect"]:
-                return _proc(returncode=1, stderr="No such network")
-            return _proc(stdout="") if argv[:2] == ["docker", "ps"] else _proc()
-
-        with patch(_RUN_DOCKER, side_effect=fake):
-            self.sc.ensure_running()
-        creates = [c for c in calls if c[:3] == ["docker", "network", "create"]]
-        self.assertEqual([["docker", "network", "create", self.sc.network]], creates)
-
-    def test_ca_cert_pem_reads_from_container(self) -> None:
-        with patch(_RUN_DOCKER, return_value=_proc(stdout=_CA_PEM)) as m:
-            self.assertEqual(_CA_PEM, self.sc.ca_cert_pem())
-        argv = m.call_args.args[0]
-        self.assertEqual(["docker", "exec", self.sc.name, "cat", GATEWAY_CA_CERT], argv)
-
-    def test_ca_cert_pem_raises_when_absent(self) -> None:
-        # timeout=0 → one probe then give up (no polling delay in the test).
-        with patch(_RUN_DOCKER, return_value=_proc(returncode=1, stderr="No such file")):
-            with self.assertRaises(GatewayError):
-                self.sc.ca_cert_pem(timeout=0)
-
-    def test_ca_cert_pem_polls_until_mitmproxy_writes_it(self) -> None:
-        # First read: CA not there yet; second read: present.
-        seq = [_proc(returncode=1, stderr="No such file"), _proc(stdout=_CA_PEM)]
-        with patch(_RUN_DOCKER, side_effect=seq), \
-                patch("bot_bottle.orchestrator.gateway.time.sleep"):
-            self.assertEqual(_CA_PEM, self.sc.ca_cert_pem(timeout=5))
-
-    def test_ensure_running_reuses_existing_network(self) -> None:
-        calls: list[list[str]] = []
-
-        def fake(argv: list[str]) -> Mock:
-            calls.append(argv)
-            return _proc(stdout="") if argv[:2] == ["docker", "ps"] else _proc()
-
-        with patch(_RUN_DOCKER, side_effect=fake):
-            self.sc.ensure_running()  # network inspect returns 0 → exists
-        self.assertEqual([], [c for c in calls if c[:3] == ["docker", "network", "create"]])
 
     def test_ensure_running_raises_on_docker_failure(self) -> None:
         def fake(argv: list[str]) -> Mock:
@@ -169,35 +85,28 @@ class TestDockerGatewayBuild(unittest.TestCase):
         with patch(_RUN_DOCKER, return_value=_proc(returncode=1)):
             self.assertFalse(self.sc.image_exists())
 
-    def test_ensure_built_builds_even_when_image_present(self) -> None:
-        # Always build (cache-aware) so a flat-source change rebuilds; the old
-        # build-if-missing silently ran a stale single-tenant image.
+    def test_ensure_built_is_noop_when_image_present(self) -> None:
+        with patch(_RUN_DOCKER, return_value=_proc(returncode=0)) as m:
+            self.sc.ensure_built()
+        self.assertEqual(1, m.call_count)  # only the image-inspect probe
+
+    def test_ensure_built_builds_from_dockerfile_when_missing(self) -> None:
         calls: list[list[str]] = []
 
-        def rec(argv: list[str]) -> Mock:
+        def fake(argv: list[str]) -> Mock:
             calls.append(argv)
-            return _proc()  # image present, build succeeds
+            if argv[:3] == ["docker", "image", "inspect"]:
+                return _proc(returncode=1)  # missing
+            return _proc()
 
-        with patch(_RUN_DOCKER, side_effect=rec):
+        with patch(_RUN_DOCKER, side_effect=fake):
             self.sc.ensure_built()
+
         builds = [c for c in calls if c[:2] == ["docker", "build"]]
         self.assertEqual(1, len(builds))
         self.assertIn(self.sc.image_ref, builds[0])
+        self.assertIn("-f", builds[0])
         self.assertTrue(any(a.endswith("Dockerfile.sidecars") for a in builds[0]))
-        self.assertNotIn("--no-cache", builds[0])
-
-    def test_ensure_built_no_cache_env_forces_full_rebuild(self) -> None:
-        calls: list[list[str]] = []
-
-        def rec(argv: list[str]) -> Mock:
-            calls.append(argv)
-            return _proc()
-
-        with patch(_RUN_DOCKER, side_effect=rec), \
-                patch.dict("os.environ", {"BOT_BOTTLE_NO_CACHE": "1"}):
-            self.sc.ensure_built()
-        builds = [c for c in calls if c[:2] == ["docker", "build"]]
-        self.assertIn("--no-cache", builds[0])
 
     def test_ensure_built_noop_when_no_dockerfile(self) -> None:
         sc = DockerGateway("busybox", dockerfile=None)
@@ -206,7 +115,12 @@ class TestDockerGatewayBuild(unittest.TestCase):
         m.assert_not_called()
 
     def test_ensure_built_raises_on_build_failure(self) -> None:
-        with patch(_RUN_DOCKER, return_value=_proc(returncode=1, stderr="build boom")):
+        def fake(argv: list[str]) -> Mock:
+            if argv[:3] == ["docker", "image", "inspect"]:
+                return _proc(returncode=1)
+            return _proc(returncode=1, stderr="build boom")
+
+        with patch(_RUN_DOCKER, side_effect=fake):
             with self.assertRaises(GatewayError):
                 self.sc.ensure_built()
 

tests/unit/test_orchestrator_lifecycle.py

@@ -1,92 +0,0 @@
-"""Unit: orchestrator+gateway container lifecycle — idempotent singleton (PRD 0070)."""
-
-from __future__ import annotations
-
-import tempfile
-import unittest
-import urllib.error
-from pathlib import Path
-from unittest.mock import MagicMock, Mock, patch
-
-from bot_bottle.orchestrator.lifecycle import (
-    ORCHESTRATOR_NAME,
-    OrchestratorService,
-    OrchestratorStartError,
-)
-from tests.unit import use_bottle_root
-
-_URLOPEN = "bot_bottle.orchestrator.lifecycle.urllib.request.urlopen"
-_RUN = "bot_bottle.orchestrator.lifecycle.run_docker"
-_GATEWAY = "bot_bottle.orchestrator.lifecycle.DockerGateway"
-_SLEEP = "bot_bottle.orchestrator.lifecycle.time.sleep"
-_MONOTONIC = "bot_bottle.orchestrator.lifecycle.time.monotonic"
-
-
-def _health(status: int) -> MagicMock:
-    m = MagicMock()
-    m.__enter__.return_value.status = status
-    return m
-
-
-class TestOrchestratorService(unittest.TestCase):
-    def setUp(self) -> None:
-        self._tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self._tmp.cleanup)
-        self.addCleanup(use_bottle_root(Path(self._tmp.name)))
-        self.svc = OrchestratorService(port=8099)
-
-    def test_urls(self) -> None:
-        self.assertEqual("http://127.0.0.1:8099", self.svc.url)
-        # The gateway reaches the control plane by container name over docker DNS.
-        self.assertEqual(f"http://{ORCHESTRATOR_NAME}:8099", self.svc.internal_url)
-
-    def test_is_healthy(self) -> None:
-        with patch(_URLOPEN, return_value=_health(200)):
-            self.assertTrue(self.svc.is_healthy())
-        with patch(_URLOPEN, side_effect=urllib.error.URLError("refused")):
-            self.assertFalse(self.svc.is_healthy())
-
-    def test_ensure_running_always_recreates_orchestrator(self) -> None:
-        # Even when a control plane is already healthy, the orchestrator is
-        # recreated so bind-mounted code changes take effect (its process
-        # won't reload). The gateway is ensured too.
-        run = Mock(return_value=Mock(returncode=0, stderr=""))
-        with patch(_URLOPEN, return_value=_health(200)), \
-                patch(_GATEWAY) as gw_cls, patch(_RUN, run), patch(_SLEEP):
-            self.assertEqual(self.svc.url, self.svc.ensure_running())
-        gw_cls.return_value.ensure_running.assert_called()   # gateway kept up
-        runs = [c.args[0] for c in run.call_args_list if c.args[0][:2] == ["docker", "run"]]
-        self.assertEqual(1, len(runs))                       # orchestrator recreated
-        self.assertIn(ORCHESTRATOR_NAME, runs[0])
-
-    def test_ensure_running_starts_orchestrator_container_when_absent(self) -> None:
-        run = Mock(return_value=Mock(returncode=0, stderr=""))
-        with patch(_URLOPEN, side_effect=[urllib.error.URLError("down"), _health(200)]), \
-                patch(_GATEWAY), patch(_RUN, run), patch(_SLEEP):
-            self.assertEqual(self.svc.url, self.svc.ensure_running())
-        runs = [c.args[0] for c in run.call_args_list if c.args[0][:2] == ["docker", "run"]]
-        self.assertEqual(1, len(runs))
-        argv = runs[0]
-        self.assertIn(ORCHESTRATOR_NAME, argv)
-        self.assertIn("--broker", argv)
-        self.assertEqual("stub", argv[argv.index("--broker") + 1])  # register-only, no socket
-        self.assertIn("bot_bottle.orchestrator", argv)
-        self.assertEqual("127.0.0.1:8099:8099", argv[argv.index("--publish") + 1])
-
-    def test_ensure_running_raises_on_timeout(self) -> None:
-        with patch(_URLOPEN, side_effect=urllib.error.URLError("down")), \
-                patch(_GATEWAY), patch(_RUN, return_value=Mock(returncode=0, stderr="")), \
-                patch(_SLEEP), patch(_MONOTONIC, side_effect=[0.0, 0.5, 2.0]):
-            with self.assertRaises(OrchestratorStartError):
-                self.svc.ensure_running(startup_timeout=1.0)
-
-    def test_stop_removes_orchestrator_and_gateway(self) -> None:
-        with patch(_RUN) as run, patch(_GATEWAY) as gw_cls:
-            self.svc.stop()
-        rms = [c.args[0] for c in run.call_args_list if c.args[0][:3] == ["docker", "rm", "--force"]]
-        self.assertTrue(any(ORCHESTRATOR_NAME in a for a in rms))
-        gw_cls.return_value.stop.assert_called_once()
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/test_orchestrator_registration.py

@@ -1,56 +0,0 @@
-"""Unit: consolidated registration inputs — egress policy round-trip (PRD 0070)."""
-
-from __future__ import annotations
-
-import json
-import unittest
-from pathlib import Path
-
-from bot_bottle.egress import EgressPlan, EgressRoute
-from bot_bottle.egress_addon_core import LOG_BLOCKS, load_config
-from bot_bottle.orchestrator.registration import (
-    RegistrationInputs,
-    egress_policy,
-    registration_inputs,
-)
-
-
-def _plan(routes: tuple[EgressRoute, ...], *, slug: str = "demo", log: int = 0) -> EgressPlan:
-    return EgressPlan(
-        slug=slug,
-        routes_path=Path("/unused/routes.yaml"),
-        routes=routes,
-        token_env_map={},
-        log=log,
-    )
-
-
-class TestEgressPolicy(unittest.TestCase):
-    def test_policy_round_trips_through_load_config(self) -> None:
-        # The policy the gateway serves must parse back to the same allow-list
-        # the per-bottle sidecar applied — moving onto the shared gateway must
-        # not change a bottle's egress.
-        routes = (EgressRoute(host="api.example.com"), EgressRoute(host="pypi.org"))
-        cfg = load_config(egress_policy(_plan(routes)))
-        self.assertEqual(("api.example.com", "pypi.org"), tuple(r.host for r in cfg.routes))
-
-    def test_policy_preserves_log_level(self) -> None:
-        plan = _plan((EgressRoute(host="x.example.com"),), log=LOG_BLOCKS)
-        self.assertEqual(LOG_BLOCKS, load_config(egress_policy(plan)).log)
-
-    def test_empty_routes_yield_deny_all(self) -> None:
-        cfg = load_config(egress_policy(_plan(())))
-        self.assertEqual((), cfg.routes)  # no routes → default-deny
-
-
-class TestRegistrationInputs(unittest.TestCase):
-    def test_bundles_policy_and_slug_metadata(self) -> None:
-        plan = _plan((EgressRoute(host="api.example.com"),), slug="my-bot")
-        inputs = registration_inputs(plan)
-        self.assertIsInstance(inputs, RegistrationInputs)
-        self.assertEqual("my-bot", json.loads(inputs.metadata)["slug"])
-        self.assertEqual(egress_policy(plan), inputs.policy)  # same blob egress_policy renders
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/test_orchestrator_registry.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import sqlite3
 import tempfile
 import unittest
 from pathlib import Path
@@ -24,20 +23,6 @@ class TestRegistryStore(unittest.TestCase):
     def tearDown(self) -> None:
         self._tmp.cleanup()
 
-    def _force_active_row(self, source_ip: str, bottle_id: str) -> None:
-        """Insert a raw active row, bypassing `register`'s same-IP supersede —
-        the only way to manufacture the ambiguity the fail-closed guard exists
-        for (crash-orphaned / externally-injected duplicate)."""
-        conn = sqlite3.connect(self.db)
-        conn.execute(
-            "INSERT INTO orchestrator_bottles "
-            "(bottle_id, source_ip, identity_token, state, created_at, metadata, policy) "
-            "VALUES (?, ?, ?, 'active', 0.0, '', '')",
-            (bottle_id, source_ip, "tok-" + bottle_id),
-        )
-        conn.commit()
-        conn.close()
-
     def test_register_mints_id_and_token(self) -> None:
         rec = self.store.register("10.243.0.1")
         self.assertTrue(rec.bottle_id)
@@ -91,29 +76,11 @@ class TestRegistryStore(unittest.TestCase):
 
     def test_attribute_ambiguous_ip_denied(self) -> None:
         # Two active bottles on one source IP is a misconfiguration — deny
-        # rather than guess (fail-closed), even with a valid token. (Forced
-        # directly: `register` now supersedes, so this can only arise from an
-        # orphaned/injected row.)
+        # rather than guess (fail-closed), even with a valid token.
         a = self.store.register("10.243.0.1", bottle_id="a")
-        self._force_active_row("10.243.0.1", "b")
+        self.store.register("10.243.0.1", bottle_id="b")
         self.assertIsNone(self.store.attribute("10.243.0.1", a.identity_token))
 
-    def test_reregister_same_source_ip_supersedes(self) -> None:
-        # Re-registering a source IP (reused IP / crash recovery / persisted
-        # DB) must supersede the prior active bottle, not add a second active
-        # row that would fail-closed the whole IP to 403.
-        a = self.store.register("10.243.0.1", bottle_id="a", policy="A")
-        b = self.store.register("10.243.0.1", bottle_id="b", policy="B")
-        # exactly one active row at that IP, and it's the new bottle
-        got = self.store.by_source_ip("10.243.0.1")
-        assert got is not None
-        self.assertEqual("b", got.bottle_id)
-        self.assertEqual("B", got.policy)
-        # the superseded bottle is gone and its token no longer attributes
-        self.assertIsNone(self.store.get("a"))
-        self.assertIsNone(self.store.attribute("10.243.0.1", a.identity_token))
-        self.assertIsNotNone(self.store.attribute("10.243.0.1", b.identity_token))
-
     def test_state_persists_across_reopen(self) -> None:
         rec = self.store.register("10.243.0.1")
         reopened = RegistryStore(self.db)
@@ -163,7 +130,7 @@ class TestRegistryStore(unittest.TestCase):
     def test_by_source_ip_unknown_or_ambiguous_denied(self) -> None:
         self.assertIsNone(self.store.by_source_ip("10.243.9.9"))  # unknown
         self.store.register("10.243.0.1", bottle_id="a")
-        self._force_active_row("10.243.0.1", "b")  # orphaned duplicate
+        self.store.register("10.243.0.1", bottle_id="b")
         self.assertIsNone(self.store.by_source_ip("10.243.0.1"))  # ambiguous
 
 

tests/unit/test_orchestrator_service.py

@@ -92,18 +92,6 @@ class TestOrchestrator(unittest.TestCase):
         assert got is not None
         self.assertEqual('{"routes":[]}', got.policy)
 
-    def test_tokens_held_in_memory_and_cleared_on_teardown(self) -> None:
-        rec = self.orch.launch_bottle("10.243.0.5", tokens={"EGRESS_TOKEN_0": "sk"})
-        self.assertEqual({"EGRESS_TOKEN_0": "sk"}, self.orch.tokens_for(rec.bottle_id))
-        # not persisted in the registry (redacted record has no tokens field)
-        self.assertNotIn("tokens", rec.redacted())
-        self.orch.teardown_bottle(rec.bottle_id)
-        self.assertEqual({}, self.orch.tokens_for(rec.bottle_id))
-
-    def test_tokens_default_empty(self) -> None:
-        rec = self.orch.launch_bottle("10.243.0.6")
-        self.assertEqual({}, self.orch.tokens_for(rec.bottle_id))
-
     def test_set_policy_live_reload(self) -> None:
         rec = self.orch.launch_bottle("10.243.0.3")
         self.assertTrue(self.orch.set_policy(rec.bottle_id, '{"x":1}'))

tests/unit/test_policy_resolver.py

@@ -89,17 +89,13 @@ class TestPolicyResolver(unittest.TestCase):
                 self.r.resolve_bottle_id("10.243.0.1", "tok")
 
     def test_resolve_policy_and_bottle_id_one_call(self) -> None:
-        payload = {"bottle_id": "b1", "policy": "P", "tokens": {"EGRESS_TOKEN_0": "s"}}
-        with patch(_URLOPEN, return_value=_resp(payload)) as m:
-            self.assertEqual(
-                ("P", "b1", {"EGRESS_TOKEN_0": "s"}),
-                self.r.resolve_policy_and_bottle_id("10.243.0.1", "t"),
-            )
-        self.assertEqual(1, m.call_count)  # policy + id + tokens from a single /resolve
+        with patch(_URLOPEN, return_value=_resp({"bottle_id": "b1", "policy": "P"})) as m:
+            self.assertEqual(("P", "b1"), self.r.resolve_policy_and_bottle_id("10.243.0.1", "t"))
+        self.assertEqual(1, m.call_count)  # both from a single /resolve
 
-    def test_resolve_policy_and_bottle_id_403_is_none_none_empty(self) -> None:
+    def test_resolve_policy_and_bottle_id_403_is_none_none(self) -> None:
         with patch(_URLOPEN, side_effect=_http_error(403)):
-            self.assertEqual((None, None, {}), self.r.resolve_policy_and_bottle_id("10.243.0.9"))
+            self.assertEqual((None, None), self.r.resolve_policy_and_bottle_id("10.243.0.9"))
 
     def test_resolve_policy_and_bottle_id_error_raises(self) -> None:
         with patch(_URLOPEN, side_effect=urllib.error.URLError("refused")):

tests/unit/test_supervise_server.py

@@ -6,7 +6,6 @@ import sys
 import tempfile
 import threading
 import time
-import types
 import unittest
 from pathlib import Path
 from unittest.mock import patch
@@ -630,57 +629,5 @@ class TestHttpEndToEnd(unittest.TestCase):
             conn.close()
 
 
-class _FakeResolver:
-    def __init__(self, bottle_id: str | None = None, raises: bool = False) -> None:
-        self._bottle_id = bottle_id
-        self._raises = raises
-        self.calls: list[str] = []
-
-    def resolve_bottle_id(self, source_ip: str, identity_token: str = "") -> str | None:
-        del identity_token
-        self.calls.append(source_ip)
-        if self._raises:
-            # Raise the exact class supervise_server catches (it imports
-            # policy_resolver flat inside the bundle, package-side in tests).
-            raise supervise_server.PolicyResolveError("orchestrator down")
-        return self._bottle_id
-
-
-def _handler(resolver: object) -> MCPHandler:
-    """A bare MCPHandler wired with a server (carrying the resolver) and a
-    client address, enough to exercise `_attributed_config` off-socket."""
-    h: MCPHandler = MCPHandler.__new__(MCPHandler)
-    h.server = types.SimpleNamespace(policy_resolver=resolver)  # type: ignore[assignment]
-    h.client_address = ("10.0.0.7", 4321)
-    return h
-
-
-class TestAttributedConfig(unittest.TestCase):
-    """Consolidated supervise: each proposal is attributed to the calling
-    bottle by source IP; single-tenant keeps the env slug (PRD 0070)."""
-
-    def test_single_tenant_keeps_env_slug(self) -> None:
-        cfg = _handler(None)._attributed_config(ServerConfig(bottle_slug="dev"))
-        self.assertEqual("dev", cfg.bottle_slug)
-
-    def test_consolidated_binds_source_ip_bottle(self) -> None:
-        r = _FakeResolver(bottle_id="bottle-x")
-        cfg = _handler(r)._attributed_config(ServerConfig(bottle_slug="ignored"))
-        self.assertEqual("bottle-x", cfg.bottle_slug)  # resolved slug wins
-        self.assertEqual(["10.0.0.7"], r.calls)
-
-    def test_unattributed_source_fails_closed(self) -> None:
-        with self.assertRaises(_RpcInternalError):
-            _handler(_FakeResolver(bottle_id=None))._attributed_config(
-                ServerConfig(bottle_slug="x")
-            )
-
-    def test_resolver_error_fails_closed(self) -> None:
-        with self.assertRaises(_RpcInternalError):
-            _handler(_FakeResolver(raises=True))._attributed_config(
-                ServerConfig(bottle_slug="x")
-            )
-
-
 if __name__ == "__main__":
     unittest.main()