feat(orchestrator): slice 5 — build the consolidated sidecar bundle image (#352)

Answers "where do we build the consolidated sidecar": nowhere, until now.

  * sidecar.py — `Sidecar.ensure_built()` (default no-op) + `DockerSidecar`
    now defaults its image to the real bundle (`bot-bottle-sidecars`) and
    `ensure_built()` builds it from `Dockerfile.sidecars` when
    `docker image inspect` shows it's missing (no-op when present or when no
    dockerfile is configured, e.g. a pre-pulled image). `image_exists()`
    added.
  * service.py — `ensure_sidecar()` now builds then runs.
  * __main__.py — `--sidecar` runs the consolidated bundle (build-if-missing).

Scope note: this builds + launches the bundle *container*; making the
running instance functional across bottles needs the per-bottle,
source-IP-keyed multi-tenant config + registration/reload, and routing
agent bottles to it — the next slices (added to PRD 0070's roadmap).

Tests: unit (docker mocked) — image_exists, ensure_built builds when
missing / no-op when present / no-op without a dockerfile / raises on build
failure; ensure_sidecar builds-then-runs; integration (gated, no heavy
build) — image_exists reflects real docker state. Full suite green (only
pre-existing /bin/sleep errors).

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

Dockerfile.sidecars

@@ -64,7 +64,6 @@ COPY --from=gitleaks-src /usr/bin/gitleaks /usr/bin/gitleaks
 COPY bot_bottle/egress_addon_core.py /app/egress_addon_core.py
 COPY bot_bottle/egress_dlp_config.py /app/egress_dlp_config.py
 COPY bot_bottle/egress_addon.py      /app/egress_addon.py
-COPY bot_bottle/policy_resolver.py   /app/policy_resolver.py
 COPY bot_bottle/dlp_detectors.py     /app/dlp_detectors.py
 COPY bot_bottle/yaml_subset.py       /app/yaml_subset.py
 COPY bot_bottle/paths.py             /app/paths.py

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

@@ -42,6 +42,7 @@ from ...git_gate import (
     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
@@ -52,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,
@@ -60,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.
@@ -97,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,82 +112,82 @@ def launch(
                 dockerfile=plan.dockerfile_path,
             )
 
-        # 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,
@@ -199,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/egress_addon.py

@@ -1,4 +1,4 @@
-"""mitmproxy addon entrypoint for the egress gateway (PRD 0017, PRD 0053).
+"""mitmproxy addon entrypoint for the egress sidecar (PRD 0017, PRD 0053).
 
 Loaded by `mitmdump -s /app/egress_addon.py` inside the
 egress container."""
@@ -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
@@ -33,7 +32,6 @@ from egress_addon_core import (  # type: ignore[import-not-found]  # pylint: dis
     is_git_push_request,
     load_config,
     match_route,
-    resolve_client_context,
     outbound_scan_headers,
     route_to_yaml_dict,
     scan_inbound,
@@ -53,26 +51,11 @@ try:
 except ImportError:  # pragma: no cover - host-side path
     from bot_bottle import supervise as _sv  # type: ignore[import-not-found]
 
-try:
-    from policy_resolver import PolicyResolver  # type: ignore[import-not-found]
-except ImportError:  # pragma: no cover - host-side path
-    from bot_bottle.policy_resolver import PolicyResolver
-
 
 DEFAULT_ROUTES_PATH = "/etc/egress/routes.yaml"
 
 INTROSPECT_HOST = "_egress.local"
 
-# Consolidated (multi-tenant) mode: when this points at the per-host
-# orchestrator's control plane, the addon resolves each client's Config by
-# source IP per request instead of using a single static routes file. Unset
-# → legacy per-bottle single-tenant mode (unchanged).
-ORCHESTRATOR_URL_ENV = "BOT_BOTTLE_ORCHESTRATOR_URL"
-
-# App-layer identity token (defense-in-depth over the source-IP invariant);
-# the agent injects it, the addon strips it so it never leaks upstream.
-IDENTITY_HEADER = "x-bot-bottle-identity"
-
 # Seconds the egress proxy holds a token-blocked request open waiting for the
 # operator's supervisor decision (PRD 0062), overridable via env.
 DEFAULT_TOKEN_ALLOW_TIMEOUT_SECONDS = 300.0
@@ -89,40 +72,20 @@ _TOKEN_ALLOW_JUSTIFICATION = (
 
 
 class EgressAddon:
-    # Class default so addons built via __new__ (e.g. in tests) default to
-    # single-tenant; __init__ sets the instance attribute for real runs.
-    _resolver: "PolicyResolver | None" = None
-
     def __init__(self) -> None:
         self.routes_path = os.environ.get("EGRESS_ROUTES", DEFAULT_ROUTES_PATH)
         self.config: Config = Config(routes=())
-        # Consolidated mode: resolve per-client Config from the orchestrator.
-        # Absent → single-tenant (static routes file); behaviour unchanged.
-        orch_url = os.environ.get(ORCHESTRATOR_URL_ENV, "").strip()
-        self._resolver = PolicyResolver(orch_url) if orch_url else None
-        # Tokens the operator has approved this session (PRD 0062), keyed by
-        # bottle so the shared gateway keeps each bottle's safelist separate —
-        # a global set would let bottle A's approved secret pass bottle B's DLP
-        # scan. In-memory only (a restart re-prompts); mutated only from the
-        # asyncio loop that runs the addon hooks, so no lock is needed.
-        self._safe_tokens: dict[str, set[str]] = {}
+        # Tokens the operator has approved this session (PRD 0062). In-memory
+        # only — a restart re-prompts. Mutated only from the asyncio loop that
+        # runs the addon hooks, so no lock is needed.
+        self.safe_tokens: set[str] = set()
         self._supervise_slug = os.environ.get("SUPERVISE_BOTTLE_SLUG", "").strip()
         self._token_allow_timeout = _token_allow_timeout_from_env(os.environ)
         self._reload(initial=True)
         self._install_sighup()
 
-    @staticmethod
-    def _supervise_available(slug: str) -> bool:
-        """Supervise is reachable for this request iff we resolved a bottle to
-        attribute its proposals to (single-tenant env slug, or a source-IP
-        -attributed bottle id). Empty → fail closed (no queue to write to)."""
-        return bool(slug)
-
-    def _safe_tokens_for(self, slug: str) -> set[str]:
-        """This bottle's operator-approved DLP safelist (PRD 0062), created on
-        first use. Keyed by bottle so the shared gateway never leaks one
-        bottle's approved token into another's scan."""
-        return self._safe_tokens.setdefault(slug, set())
+    def _supervise_available(self) -> bool:
+        return bool(self._supervise_slug)
 
     def _reload(self, *, initial: bool = False) -> None:
         try:
@@ -231,28 +194,6 @@ 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."""
-        if self._resolver is None:
-            return self.config, self._supervise_slug, os.environ
-        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
-
     async def request(self, flow: http.HTTPFlow) -> None:
         request_path, _, query = flow.request.path.partition("?")
 
@@ -260,14 +201,12 @@ class EgressAddon:
             self._serve_introspection(flow, request_path)
             return
 
-        config, slug, env = 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)
+        route = match_route(self.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):
                 return
             # The redact policy may have rewritten the request line; recompute
             # the path/query the git checks below rely on.
@@ -285,7 +224,7 @@ class EgressAddon:
 
         if is_git_fetch_request(request_path, query):
             git_decision = decide_git_fetch(
-                config.routes, flow.request.pretty_host,
+                self.config.routes, flow.request.pretty_host,
             )
             if git_decision.action == "block":
                 self._block(
@@ -296,17 +235,17 @@ class EgressAddon:
                 return
 
         # Strip agent-set Authorization after DLP scan so smuggled tokens
-        # are caught above; the route may inject gateway-owned auth below.
+        # are caught above; the route may inject sidecar-owned auth below.
         flow.request.headers.pop("authorization", None)
 
         # Build headers mapping for match evaluation
         req_headers = {k.lower(): v for k, v in flow.request.headers.items()}
 
         decision = decide(
-            config.routes,
+            self.config.routes,
             flow.request.pretty_host,
             request_path,
-            env,
+            os.environ,
             request_method=flow.request.method,
             request_headers=req_headers,
         )
@@ -318,7 +257,7 @@ class EgressAddon:
         if decision.inject_authorization is not None:
             flow.request.headers["authorization"] = decision.inject_authorization
 
-        if config.log >= LOG_FULL:
+        if self.config.log >= LOG_FULL:
             self._log_request(flow)
 
     def _block_dlp(self, flow: http.HTTPFlow, result: ScanResult) -> None:
@@ -331,13 +270,10 @@ class EgressAddon:
         self,
         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,8 +290,8 @@ class EgressAddon:
                 flow.request.pretty_host, request_path, query, headers, "",
             )
             result = scan_outbound(
-                route, scan_text, env,
-                safe_tokens=self._safe_tokens_for(slug), crlf_text=crlf_text,
+                route, scan_text, os.environ,
+                safe_tokens=self.safe_tokens, crlf_text=crlf_text,
             )
             if result is None or result.severity != "block":
                 return True
@@ -365,7 +301,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",
@@ -390,34 +326,32 @@ class EgressAddon:
 
             # supervise (default): hold the request for operator approval.
             # Fall back to a hard 403 when supervise isn't wired for the bottle.
-            if not self._supervise_available(slug):
+            if not self._supervise_available():
                 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)
             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 +364,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(
@@ -438,27 +372,21 @@ class EgressAddon:
         flow: http.HTTPFlow,
         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`)."""
+        Returns True if the operator approved (the matched value is added to
+        `self.safe_tokens` 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(
-            bottle_slug=slug,
+            bottle_slug=self._supervise_slug,
             tool=_sv.TOOL_EGRESS_TOKEN_ALLOW,
             proposed_file=payload,
             justification=_TOKEN_ALLOW_JUSTIFICATION,
@@ -481,13 +409,13 @@ class EgressAddon:
             **self._req_ctx(flow),
         }) + "\n")
 
-        response = await self._await_token_response(proposal.id, slug)
-        _sv.archive_proposal(slug, proposal.id)
+        response = await self._await_token_response(proposal.id)
+        _sv.archive_proposal(self._supervise_slug, proposal.id)
 
         if response is not None and response.status in (
             _sv.STATUS_APPROVED, _sv.STATUS_MODIFIED,
         ):
-            self._safe_tokens_for(slug).add(result.matched)
+            self.safe_tokens.add(result.matched)
             if self.config.log >= LOG_BLOCKS:
                 sys.stderr.write(json.dumps({
                     "event": "egress_token_allowed",
@@ -510,7 +438,6 @@ class EgressAddon:
     async def _await_token_response(
         self,
         proposal_id: str,
-        slug: str,
     ) -> "_sv.Response | None":
         """Poll the DB for the operator's response without blocking the
         proxy event loop. Returns the Response, or None on timeout."""
@@ -518,7 +445,7 @@ class EgressAddon:
         deadline = loop.time() + self._token_allow_timeout
         while True:
             try:
-                return _sv.read_response(slug, proposal_id)
+                return _sv.read_response(self._supervise_slug, proposal_id)
             except (OSError, ValueError, KeyError):
                 # Not written yet, or a partial/malformed write — retry until
                 # the deadline, then fail closed.
@@ -572,9 +499,6 @@ class EgressAddon:
         """
         if flow.websocket is None:  # type: ignore[union-attr]
             return
-        # WebSocket DLP runs against the static config only (single-tenant); in
-        # the consolidated gateway self.config has no routes, so this is inert
-        # until websocket routing is made source-IP-aware (a separate slice).
         route = match_route(self.config.routes, flow.request.pretty_host)
         if route is None:
             return
@@ -585,7 +509,7 @@ class EgressAddon:
             # not an injection vector here — scan only for credential leakage.
             result = scan_outbound(
                 route, content, os.environ,
-                safe_tokens=self._safe_tokens_for(self._supervise_slug), crlf_text="",
+                safe_tokens=self.safe_tokens, crlf_text="",
             )
             if result is not None and result.severity == "block":
                 sys.stderr.write(f"egress DLP: {result.reason}\n")

bot_bottle/egress_addon_core.py

@@ -3,7 +3,7 @@
 Split out of `egress_addon.py` so the host's unit tests can
 exercise the parse + decision functions without depending on the
 `mitmproxy` package. The companion module wraps these with the
-`mitmproxy.http.HTTPFlow` API and is loaded inside the gateway
+`mitmproxy.http.HTTPFlow` API and is loaded inside the sidecar
 container.
 
 Imports: stdlib + `yaml_subset` (which is itself stdlib-only and
@@ -22,7 +22,7 @@ except ImportError:  # pragma: no cover - host-side path
     from .yaml_subset import YamlSubsetError, parse_yaml_subset
 
 # DLP detector-config parsing lives in a sibling module (also flat-bundled
-# into the gateway — see Dockerfile.sidecars). Re-exported below so existing
+# into the sidecar — see Dockerfile.sidecars). Re-exported below so existing
 # `from egress_addon_core import ON_MATCH_*` callers keep working.
 try:
     from egress_dlp_config import (  # type: ignore[import-not-found]
@@ -120,7 +120,7 @@ class ScanResult:
     reason: str
     location: str = ""  # where the match was found, e.g. "body", "authorization header"
     context: str = ""   # surrounding text with the match replaced by REDACT
-    # Raw substring the detector matched. Used inside the gateway to key the
+    # Raw substring the detector matched. Used inside the sidecar to key the
     # supervisor-approved "safe tokens" set (PRD 0062); never logged or written
     # to a proposal file. Empty for structural detectors (CRLF) that carry no
     # safelist-able value.
@@ -413,70 +413,6 @@ def load_config(text: str) -> "Config":
     return parse_config(payload)
 
 
-class PolicyResolverLike(typing.Protocol):
-    """The bit of `policy_resolver.PolicyResolver` this module needs — kept a
-    Protocol so egress_addon_core stays free of that import."""
-
-    def resolve(self, source_ip: str, identity_token: str = ...) -> "str | None":
-        ...
-
-
-def _config_from_policy(policy: "str | None") -> "Config":
-    """Parse a resolved policy blob into a Config, fail-closed: None / empty /
-    unparseable all become a deny-all Config (no routes → every request
-    blocked)."""
-    if not policy:
-        return Config(routes=())  # unattributed or empty → deny-all
-    try:
-        return load_config(policy)
-    except ValueError:
-        return Config(routes=())  # unparseable policy → deny
-
-
-def resolve_client_config(
-    resolver: PolicyResolverLike, client_ip: str, identity_token: str = ""
-) -> "Config":
-    """The calling client's egress Config, resolved from the orchestrator via
-    `resolver` and parsed — **fail-closed**. An unattributed client (None), a
-    resolver error, or an unparseable policy all yield a deny-all Config (no
-    routes → every request blocked). A compromised, absent, or confused
-    orchestrator must never *widen* a bottle's egress."""
-    try:
-        policy = resolver.resolve(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)
-
-
-class ContextResolverLike(typing.Protocol):
-    """The bit of `policy_resolver.PolicyResolver` `resolve_client_context`
-    needs — one round-trip returning policy, bottle id, and auth tokens."""
-
-    def resolve_policy_and_bottle_id(
-        self, source_ip: str, identity_token: str = ...,
-    ) -> "tuple[str | None, str | None, dict[str, str]]":
-        ...
-
-
-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 —
-    **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."""
-    try:
-        policy, bottle_id, tokens = 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
-
-
 # ---------------------------------------------------------------------------
 # Match evaluation
 # ---------------------------------------------------------------------------
@@ -677,7 +613,7 @@ def outbound_scan_headers(
 ) -> dict[str, str]:
     """Return request headers that should be included in outbound DLP.
 
-    Routes that inject gateway-owned auth always strip the agent's
+    Routes that inject sidecar-owned auth always strip the agent's
     Authorization header before forwarding. Scanning that header first
     creates false positives for provider clients that insist on sending
     their own bearer-shaped placeholder, while still not changing what
@@ -728,7 +664,7 @@ def scan_outbound(
     crlf_text: str | None = None,
 ) -> ScanResult | None:
     # Lazy import to avoid circular deps and keep dlp_detectors optional
-    # at import time (the gateway copies it flat alongside this file).
+    # at import time (the sidecar copies it flat alongside this file).
     try:
         from dlp_detectors import (  # type: ignore[import-not-found]
             scan_crlf_injection,
@@ -868,10 +804,6 @@ __all__ = [
     "is_git_push_request",
     "is_git_fetch_request",
     "load_config",
-    "resolve_client_config",
-    "resolve_client_context",
-    "PolicyResolverLike",
-    "ContextResolverLike",
     "match_route",
     "outbound_scan_headers",
     "parse_config",

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

@@ -6,15 +6,6 @@ where the guest reaches the sidecar over the point-to-point TAP). The
 wrapper serves the same `/git/*.git` bare repos through
 `git http-backend`, so pre-receive and upstream forwarding remain the
 git-gate enforcement point.
-
-Consolidated (PRD 0070): when `BOT_BOTTLE_ORCHESTRATOR_URL` is set, one
-shared gateway serves every bottle, and each request is served from the
-calling bottle's repo namespace (`<root>/<bottle_id>`), attributed from
-the unspoofable source IP via the orchestrator. Per-repo credentials +
-hooks scope by repo directory, so isolating the *root* per bottle isolates
-its creds too. Unattributed clients fail closed (404). Unset → the legacy
-per-bottle single-tenant flat root, unchanged — a transitional path that
-gets stripped out once every backend runs the consolidated gateway.
 """
 
 from __future__ import annotations
@@ -22,86 +13,13 @@ from __future__ import annotations
 import os
 import subprocess
 import sys
-import typing
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from urllib.parse import urlsplit
 
-# policy_resolver ships flat alongside this file in the sidecar bundle
-# image (see Dockerfile.sidecars); the bot_bottle.* fallback is the
-# host-side / test path. Mirrors egress_addon's import shape.
-try:
-    from policy_resolver import (  # type: ignore[import-not-found]
-        PolicyResolveError,
-        PolicyResolver,
-    )
-except ImportError:  # pragma: no cover - host-side path
-    from bot_bottle.policy_resolver import PolicyResolveError, PolicyResolver
-
 
 DEFAULT_PORT = 9420
 
-# Consolidated (multi-tenant) mode: when this points at the per-host
-# orchestrator's control plane, the backend serves each request from the
-# *calling* bottle's repo namespace, selected by source IP, instead of a
-# single flat repo root. Unset → legacy per-bottle single-tenant mode
-# (unchanged). Same env the egress addon reads, so one orchestrator setting
-# flips the whole shared gateway multi-tenant.
-ORCHESTRATOR_URL_ENV = "BOT_BOTTLE_ORCHESTRATOR_URL"
-
-# App-layer identity token (defense-in-depth over the source-IP invariant);
-# the agent injects it, the backend reads it for attribution and never
-# forwards it to `git http-backend`. Mirrors egress_addon.IDENTITY_HEADER
-# (duplicated, not imported: egress_addon pulls in mitmproxy).
-IDENTITY_HEADER = "x-bot-bottle-identity"
-
-# Default flat repo root (single-tenant, and the base under which
-# consolidated mode nests each sandbox's namespace).
-DEFAULT_REPO_ROOT = "/git"
-
-
-class ResolverLike(typing.Protocol):
-    """Structural type for the resolver `resolve_sandbox_root` needs — just
-    `resolve_bottle_id`. A Protocol so tests can pass a fake without
-    importing PolicyResolver (mirrors egress_addon_core.PolicyResolverLike)."""
-
-    def resolve_bottle_id(
-        self, source_ip: str, identity_token: str = ...,
-    ) -> "str | None": ...
-
-
-def resolve_sandbox_root(
-    resolver: "ResolverLike | None",
-    base_root: Path,
-    source_ip: str,
-    identity_token: str = "",
-) -> Path | None:
-    """The per-sandbox repo root to serve this request from, or None to
-    deny (404).
-
-    Single-tenant (`resolver is None`): the flat `base_root`, unchanged.
-    NOTE: this legacy per-bottle single-tenant path is transitional — it
-    will be stripped out once every backend runs the consolidated gateway
-    (PRD 0070), leaving only the source-IP-attributed path below.
-
-    Consolidated: `base_root/<bottle_id>`, where the sandbox is attributed
-    from the source IP via the orchestrator. Fail-closed — an unattributed
-    client, a resolver error, or a namespace that would escape `base_root`
-    all deny, so one sandbox can never reach another's repos."""
-    if resolver is None:
-        return base_root
-    try:
-        bottle_id = resolver.resolve_bottle_id(source_ip, identity_token)
-    except PolicyResolveError:
-        return None  # orchestrator unreachable/errored → deny
-    if not bottle_id:
-        return None  # unattributed → deny
-    base = base_root.resolve()
-    namespace = (base / bottle_id).resolve()
-    if base not in namespace.parents:
-        return None  # bottle_id tried to escape the root → deny
-    return namespace
-
 # Mirrors git_gate_render.GIT_GATE_TIMEOUT_SECS. Duplicated rather than
 # imported: this module ships as a flat top-level sibling in the sidecar
 # bundle image (see Dockerfile.sidecars), not as part of the bot_bottle
@@ -122,25 +40,10 @@ class GitHttpHandler(BaseHTTPRequestHandler):
     def do_POST(self) -> None:
         self._run_backend()
 
-    def _sandbox_root(self) -> Path | None:
-        """This request's per-sandbox repo root, or None to deny. Single-tenant
-        unless the server was started with a resolver (consolidated mode), in
-        which case the root is the calling sandbox's source-IP-selected
-        namespace. `GIT_PROJECT_ROOT` keeps git's own env-var name."""
-        base = Path(os.environ.get("GIT_PROJECT_ROOT", DEFAULT_REPO_ROOT))
-        resolver = getattr(self.server, "policy_resolver", None)
-        token = self.headers.get(IDENTITY_HEADER, "")
-        return resolve_sandbox_root(resolver, base, self.client_address[0], token)
-
     def _run_backend(self) -> None:
-        sandbox_root = self._sandbox_root()
-        if sandbox_root is None:
-            # Unattributed / resolver error: deny before touching any repo.
-            self.send_error(404)
-            return
         parsed = urlsplit(self.path)
         if self._is_upload_pack(parsed.path, parsed.query):
-            repo_dir = self._repo_dir(sandbox_root, parsed.path)
+            repo_dir = self._repo_dir(parsed.path)
             if repo_dir is None:
                 self.send_error(404)
                 return
@@ -174,7 +77,7 @@ class GitHttpHandler(BaseHTTPRequestHandler):
                 return
         env = os.environ.copy()
         env.update({
-            "GIT_PROJECT_ROOT": str(sandbox_root),
+            "GIT_PROJECT_ROOT": os.environ.get("GIT_PROJECT_ROOT", "/git"),
             "GIT_HTTP_EXPORT_ALL": "1",
             "REQUEST_METHOD": self.command,
             "PATH_INFO": parsed.path,
@@ -188,14 +91,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"),
@@ -228,8 +123,8 @@ class GitHttpHandler(BaseHTTPRequestHandler):
         )
         self._write_cgi_response(proc.stdout)
 
-    def _repo_dir(self, sandbox_root: Path, path: str) -> Path | None:
-        root = sandbox_root.resolve()
+    def _repo_dir(self, path: str) -> Path | None:
+        root = Path(os.environ.get("GIT_PROJECT_ROOT", "/git")).resolve()
         relative = path.lstrip("/").split(".git", 1)[0] + ".git"
         candidate = (root / relative).resolve()
         if root not in (candidate, *candidate.parents):
@@ -286,13 +181,7 @@ class GitHttpHandler(BaseHTTPRequestHandler):
 def main() -> int:
     port = int(os.environ.get("GIT_HTTP_PORT", str(DEFAULT_PORT)))
     server = ThreadingHTTPServer(("0.0.0.0", port), GitHttpHandler)
-    orch_url = os.environ.get(ORCHESTRATOR_URL_ENV, "").strip()
-    # Consolidated mode: resolve each request's sandbox namespace by source
-    # IP. Absent → single-tenant (flat repo root); behaviour unchanged.
-    resolver = PolicyResolver(orch_url) if orch_url else None
-    server.policy_resolver = resolver  # type: ignore[attr-defined]
-    mode = "multi-tenant" if orch_url else "single-tenant"
-    sys.stdout.write(f"git-http listening on 0.0.0.0:{port} ({mode})\n")
+    sys.stdout.write(f"git-http listening on 0.0.0.0:{port}\n")
     sys.stdout.flush()
     server.serve_forever()
     return 0

bot_bottle/orchestrator/__init__.py

@@ -1,6 +1,6 @@
 """Per-host orchestrator service (PRD 0070).
 
-A single persistent per-host service that will run the gateway functions
+A single persistent per-host service that will run the sidecar functions
 (egress / git-gate / supervise), coordinate with the console, and broker
 agent launches. This package is being built bottom-up, starting with the
 backend-neutral "consolidation core" that needs no VM packaging:
@@ -10,15 +10,15 @@ backend-neutral "consolidation core" that needs no VM packaging:
   * `broker`        — the signed, structured launch-request contract + a
                       `LaunchBroker` (stub for the harness) that verifies
                       provenance before acting.
-  * `gateway`       — the consolidated per-host gateway: a `Gateway`
+  * `sidecar`       — the consolidated per-host sidecar: a `Sidecar`
                       lifecycle contract (idempotent singleton) + a
-                      `DockerGateway` impl. One gateway shared by all
+                      `DockerSidecar` impl. One sidecar shared by all
                       bottles instead of one per bottle.
   * `service`       — the `Orchestrator`: owns the registry, brokers the
                       launch lifecycle (launch/teardown), manages the
-                      shared gateway, attributes.
+                      shared sidecar, attributes.
   * `control_plane` — the HTTP control-plane RPC (launch / teardown /
-                      list / attribute / gateway / health).
+                      list / attribute / sidecar / health).
 
 The actual backend-native launch (a real docker/firecracker broker) and
 the egress/git/supervise data plane land in later slices once this core is
@@ -38,7 +38,7 @@ from .broker import (
     verify_request,
 )
 from .docker_broker import DockerBroker, DockerBrokerError
-from .gateway import DockerGateway, Gateway, GatewayError
+from .sidecar import DockerSidecar, Sidecar, SidecarError
 from .service import Orchestrator
 from .control_plane import ControlPlaneServer, dispatch, make_server
 
@@ -52,9 +52,9 @@ __all__ = [
     "StubBroker",
     "DockerBroker",
     "DockerBrokerError",
-    "Gateway",
-    "DockerGateway",
-    "GatewayError",
+    "Sidecar",
+    "DockerSidecar",
+    "SidecarError",
     "sign_request",
     "verify_request",
     "Orchestrator",

bot_bottle/orchestrator/__main__.py

@@ -21,7 +21,7 @@ from .control_plane import make_server
 from .docker_broker import DockerBroker
 from .registry import RegistryStore, default_db_path
 from .service import Orchestrator
-from .gateway import DockerGateway, Gateway
+from .sidecar import DockerSidecar, Sidecar
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -38,7 +38,7 @@ def main(argv: list[str] | None = None) -> int:
         help="launch broker: 'stub' records requests; 'docker' runs containers",
     )
     parser.add_argument(
-        "--gateway", action="store_true",
+        "--sidecar", action="store_true",
         help="run one consolidated per-host sidecar bundle (build-if-missing)",
     )
     args = parser.parse_args(argv)
@@ -51,20 +51,14 @@ 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
-    )
-    orchestrator = Orchestrator(registry, broker, secret, gateway)
+    sidecar: Sidecar | None = DockerSidecar() if args.sidecar else None
+    orchestrator = Orchestrator(registry, broker, secret, sidecar)
 
-    # One persistent per-host gateway, shared by every bottle: build the
+    # One persistent per-host sidecar, shared by every bottle: build the
     # bundle image if missing, then bring the singleton up (idempotent).
-    if gateway is not None:
-        orchestrator.ensure_gateway()
-        log.info("consolidated gateway ensured", context={"name": gateway.name})
+    if sidecar is not None:
+        orchestrator.ensure_sidecar()
+        log.info("consolidated sidecar ensured", context={"name": sidecar.name})
 
     server = make_server(orchestrator, host=args.host, port=args.port)
     bound_host, bound_port = server.server_address[0], server.server_address[1]

bot_bottle/orchestrator/broker.py

@@ -9,7 +9,7 @@ The request it sends is:
     request can't be coerced into launching an arbitrary payload; and
   * **signed** — wrapped as a compact JWS/JWT the broker verifies before
     acting, so a *compromised co-located component* (an agent-facing
-    gateway, say) can't forge a launch. This is the concrete form of the
+    sidecar, say) can't forge a launch. This is the concrete form of the
     "structured requests only" rule in the PRD security review.
 
 Signing is **HS256** over a secret shared by the orchestrator (signer) and

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

@@ -4,18 +4,14 @@ The backend-agnostic control-plane RPC (CLI / console -> orchestrator) over
 **HTTP** — the universal transport chosen in 0070 (works on every host; no
 vsock / unix-socket portability caveats):
 
-    GET    /health                    -> 200 {"status": "ok"}
-    GET    /gateway                   -> 200 {"configured", ["name","running"]}
-    GET    /bottles                   -> 200 {"bottles": [ <redacted record>, ...]}
-    POST   /bottles                   -> 201 {"bottle_id","identity_token"}  (launch)
-                                         body: {"source_ip", ["image_ref"],
-                                                ["metadata"], ["policy"]}
-    PUT    /bottles/<bottle_id>/policy -> 200 {"updated": true} | 404  (live reload)
-                                         body: {"policy"}
-    DELETE /bottles/<bottle_id>        -> 200 {"torn_down": true} | 404  (teardown)
-    POST   /attribute                 -> 200 {"bottle_id"} | 403
-    POST   /resolve                   -> 200 {"bottle_id","policy"} | 403
-                                         body: {"source_ip","identity_token"}
+    GET    /health              -> 200 {"status": "ok"}
+    GET    /sidecar             -> 200 {"configured", ["name", "running"]}
+    GET    /bottles             -> 200 {"bottles": [ <redacted record>, ... ]}
+    POST   /bottles             -> 201 {"bottle_id", "identity_token"}    (launch)
+                                   body: {"source_ip", ["image_ref"], ["metadata"]}
+    DELETE /bottles/<bottle_id> -> 200 {"torn_down": true} | 404          (teardown)
+    POST   /attribute           -> 200 {"bottle_id"} | 403
+                                   body: {"source_ip", "identity_token"}
 
 `POST /bottles` / `DELETE` drive the full launch lifecycle: they mint (or
 tear down) the bottle in the registry AND broker the backend-native launch
@@ -34,7 +30,6 @@ import http.server
 import json
 import os
 import socketserver
-import sys
 import typing
 from urllib.parse import urlsplit
 
@@ -54,7 +49,7 @@ def _parse_json_object(body: bytes) -> Json:
     return obj
 
 
-def dispatch(  # pylint: disable=too-many-return-statements,too-many-branches
+def dispatch(  # pylint: disable=too-many-return-statements
     orch: Orchestrator, method: str, path: str, body: bytes
 ) -> tuple[int, Json]:
     """Route one control-plane request to a (status, payload) pair. Pure —
@@ -64,8 +59,8 @@ def dispatch(  # pylint: disable=too-many-return-statements,too-many-branches
     if method == "GET" and route == "/health":
         return 200, {"status": "ok"}
 
-    if method == "GET" and route == "/gateway":
-        return 200, orch.gateway_status()
+    if method == "GET" and route == "/sidecar":
+        return 200, orch.sidecar_status()
 
     if method == "GET" and route == "/bottles":
         return 200, {"bottles": [r.redacted() for r in orch.registry.all()]}
@@ -80,33 +75,13 @@ def dispatch(  # pylint: disable=too-many-return-statements,too-many-branches
             return 400, {"error": "source_ip (string) is required"}
         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}
 
-    if method == "PUT" and route.startswith("/bottles/") and route.endswith("/policy"):
-        bottle_id = route[len("/bottles/"):-len("/policy")]
-        try:
-            data = _parse_json_object(body)
-        except ValueError as e:
-            return 400, {"error": f"invalid JSON: {e}"}
-        policy = data.get("policy")
-        if not isinstance(policy, str):
-            return 400, {"error": "policy (string) is required"}
-        if orch.set_policy(bottle_id, policy):
-            return 200, {"updated": True}
-        return 404, {"error": "no such bottle"}
-
     if method == "DELETE" and route.startswith("/bottles/"):
         bottle_id = route[len("/bottles/"):]
         if orch.teardown_bottle(bottle_id):
@@ -127,29 +102,6 @@ def dispatch(  # pylint: disable=too-many-return-statements,too-many-branches
             return 403, {"error": "unattributed"}
         return 200, {"bottle_id": rec.bottle_id}
 
-    if method == "POST" and route == "/resolve":
-        # The per-request lookup the multi-tenant gateway makes: returns the
-        # bottle's policy. identity_token is OPTIONAL — absent means resolve
-        # by source IP alone (network-layer attribution).
-        try:
-            data = _parse_json_object(body)
-        except ValueError as e:
-            return 400, {"error": f"invalid JSON: {e}"}
-        source_ip = data.get("source_ip")
-        token = data.get("identity_token")
-        if not isinstance(source_ip, str) or not source_ip:
-            return 400, {"error": "source_ip (string) is required"}
-        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 404, {"error": "not found"}
 
 
@@ -163,20 +115,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")
@@ -190,9 +134,6 @@ class Handler(http.server.BaseHTTPRequestHandler):
     def do_POST(self) -> None:
         self._serve("POST")
 
-    def do_PUT(self) -> None:
-        self._serve("PUT")
-
     def do_DELETE(self) -> None:
         self._serve("DELETE")
 

bot_bottle/orchestrator/gateway.py

@@ -1,228 +0,0 @@
-"""The consolidated per-host gateway (PRD 0070).
-
-The core consolidation win: **one** persistent gateway per host, shared by
-every bottle, instead of a sidecar bundle per bottle. It's safe to share
-because the attribution invariant (source IP + identity token, see
-`registry`) lets the gateway attribute each request to the right bottle —
-so per-bottle policy lives in one long-lived process keyed on who's calling.
-
-`Gateway` is the backend-neutral lifecycle contract (mirrors `LaunchBroker`):
-ensure the single instance is up, report it, tear it down. `DockerGateway`
-is the docker implementation; a firecracker gateway VM slots in later.
-
-The defining behaviour is **idempotent singleton**: `ensure_running` starts
-the instance if absent and is a no-op if it's already up, so N bottle
-launches never spawn N gateways.
-"""
-
-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
-# the whole backend layer into the lean orchestrator (see #359); unify when
-# that lands. Env override matches the backend's BOT_BOTTLE_SIDECAR_IMAGE.
-GATEWAY_IMAGE = os.environ.get("BOT_BOTTLE_SIDECAR_IMAGE", "bot-bottle-sidecars:latest")
-GATEWAY_DOCKERFILE = "Dockerfile.sidecars"
-_REPO_ROOT = Path(__file__).resolve().parents[2]
-
-
-class GatewayError(Exception):
-    """The shared gateway failed to build/start/stop (non-zero `docker` exit)."""
-
-
-class Gateway(abc.ABC):
-    """Lifecycle of the single per-host gateway. Backend-neutral."""
-
-    name: str
-
-    def ensure_built(self) -> None:
-        """Ensure the gateway's image / rootfs exists, building it if needed.
-        Default: nothing to build (e.g. a stub or a pre-pulled image)."""
-        return
-
-    @abc.abstractmethod
-    def ensure_running(self) -> None:
-        """Start the gateway if it isn't already up. Idempotent: a no-op
-        when it's already running (that's the whole point — one per host).
-        Assumes the image exists — call `ensure_built()` first."""
-
-    @abc.abstractmethod
-    def is_running(self) -> bool:
-        """True iff the gateway instance is currently up."""
-
-    @abc.abstractmethod
-    def stop(self) -> None:
-        """Remove the gateway. Idempotent — absent is success."""
-
-
-class DockerGateway(Gateway):
-    """The consolidated gateway as a single, fixed-name Docker container.
-
-    `image_ref` defaults to the real sidecar-bundle image; `ensure_built`
-    builds it from `Dockerfile.sidecars` when it's missing. (Note: slice 5
-    builds + launches the bundle container; wiring its per-bottle,
-    source-IP-keyed config is a later slice — see PRD 0070.)"""
-
-    def __init__(
-        self,
-        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,
-    ) -> 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
-
-    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:
-            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)
-        if proc.returncode != 0:
-            raise GatewayError(f"gateway image build failed: {proc.stderr.strip()}")
-
-    def is_running(self) -> bool:
-        proc = run_docker([
-            "docker", "ps",
-            "--filter", f"name=^{self.name}$",
-            "--filter", "status=running",
-            "--format", "{{.Names}}",
-        ])
-        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():
-            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.
-        run_docker(["docker", "rm", "--force", self.name])
-        argv = [
-            "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}",
-        ]
-        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)
-        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:
-            raise GatewayError(f"gateway failed to stop: {proc.stderr.strip()}")
-
-
-__all__ = [
-    "Gateway", "DockerGateway", "GatewayError",
-    "GATEWAY_NAME", "GATEWAY_LABEL", "GATEWAY_IMAGE", "GATEWAY_NETWORK",
-    "GATEWAY_CA_VOLUME", "GATEWAY_CA_CERT",
-]

bot_bottle/orchestrator/lifecycle.py

@@ -1,209 +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 hashlib
-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"
-# Baked onto the container as a label so `ensure_running` can tell whether the
-# running process is executing the *current* bind-mounted source — see
-# `_source_hash`.
-ORCHESTRATOR_SOURCE_HASH_LABEL = "bot-bottle-orchestrator-source-hash"
-
-# 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."""
-
-
-def _source_hash(repo_root: Path) -> str:
-    """Content hash of the orchestrator's bind-mounted Python source (the
-    `bot_bottle` package the control-plane process imports). This only
-    changes when the code that would actually run inside the container
-    changes — `ensure_running` recreates the container on a mismatch and
-    otherwise leaves a healthy one alone, so a bottle launch that isn't
-    accompanied by a code change doesn't restart the process and drop every
-    *other* active bottle's in-memory egress tokens (`Orchestrator._tokens`
-    in `service.py`, never persisted to disk by design)."""
-    h = hashlib.sha256()
-    for path in sorted((repo_root / "bot_bottle").rglob("*.py")):
-        h.update(str(path.relative_to(repo_root)).encode())
-        h.update(path.read_bytes())
-    return h.hexdigest()
-
-
-class OrchestratorService:
-    """Manages the orchestrator control-plane container + the shared gateway.
-    Callers only need `ensure_running()` + `url`."""
-
-    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,
-    ) -> None:
-        self.port = port
-        self.network = network
-        self.image = image
-        self._repo_root = repo_root
-        self._host_root = host_root or bot_bottle_root()
-
-    @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://{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, source_hash: str) -> None:
-        """Start the control-plane container (idempotent: clears a stale
-        fixed-name container first). Register-only broker → no docker socket.
-        Labels the container with `source_hash` so a later `ensure_running`
-        can detect a real code change (see `_source_hash`)."""
-        run_docker(["docker", "rm", "--force", ORCHESTRATOR_NAME])
-        proc = run_docker([
-            "docker", "run", "--detach",
-            "--name", ORCHESTRATOR_NAME,
-            "--label", ORCHESTRATOR_LABEL,
-            "--label", f"{ORCHESTRATOR_SOURCE_HASH_LABEL}={source_hash}",
-            "--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 _orchestrator_source_current(self, current_hash: str) -> bool:
-        """True iff the running orchestrator container was created from the
-        *current* bind-mounted source. Mirrors `DockerGateway`'s
-        image-staleness check, but by content hash rather than image id since
-        the orchestrator runs bind-mounted source, not a built image."""
-        if not self._container_running(ORCHESTRATOR_NAME):
-            return False
-        proc = run_docker([
-            "docker", "inspect", "--format",
-            "{{ index .Config.Labels \"" + ORCHESTRATOR_SOURCE_HASH_LABEL + "\" }}",
-            ORCHESTRATOR_NAME,
-        ])
-        if proc.returncode != 0:
-            return True  # can't compare -> don't churn a working container
-        return proc.stdout.strip() == current_hash
-
-    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 running
-        current code 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
-
-        # Recreate the orchestrator container only when its bind-mounted
-        # source has actually changed since it started — its Python process
-        # loaded that code at startup and won't reload, so a stale container
-        # would keep running OLD control-plane code. Recreating on *every*
-        # launch (the prior behaviour) would drop every other active
-        # bottle's in-memory egress tokens each time a new bottle starts,
-        # since the orchestrator process holds them only in memory (#381).
-        current_hash = _source_hash(self._repo_root)
-        if self.is_healthy() and self._orchestrator_source_current(current_hash):
-            return self.url
-
-        log.info("starting orchestrator container", context={"name": ORCHESTRATOR_NAME})
-        self._run_orchestrator_container(current_hash)
-
-        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", 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

@@ -64,13 +64,9 @@ class BottleRecord:
     identity_token: str
     state: str = "active"
     created_at: float = 0.0
-    # Opaque JSON blob for forward-compat (pool slot, ...) — the registry
-    # doesn't interpret it, so new fields need no migration.
+    # Opaque JSON blob for forward-compat (policy refs, pool slot, ...) —
+    # the registry doesn't interpret it, so new fields need no migration.
     metadata: str = ""
-    # The bottle's gateway policy (opaque JSON — egress allowlist / routes /
-    # git config). The registry stores and serves it verbatim, keyed by
-    # source IP; the multi-tenant gateway interprets it.
-    policy: str = ""
 
     def redacted(self) -> dict[str, object]:
         """Public view for listing — never exposes the identity token."""
@@ -80,7 +76,6 @@ class BottleRecord:
             "state": self.state,
             "created_at": self.created_at,
             "metadata": self.metadata,
-            "policy": self.policy,
         }
 
 
@@ -102,10 +97,6 @@ _MIGRATIONS = TableMigrations(
         # the "one active bottle per source IP" check cheap.
         "CREATE INDEX IF NOT EXISTS idx_orchestrator_bottles_source_ip "
         "ON orchestrator_bottles (source_ip)",
-        # v3 — per-bottle policy (opaque JSON the gateway interprets): the
-        # egress allowlist / routes / git config selected by source IP. The
-        # multi-tenant gateway resolves it per request via `attribute`.
-        "ALTER TABLE orchestrator_bottles ADD COLUMN policy TEXT NOT NULL DEFAULT ''",
     ],
 )
 
@@ -119,7 +110,6 @@ def _row_to_record(row: sqlite3.Row) -> BottleRecord:
         state=row["state"],
         created_at=row["created_at"],
         metadata=row["metadata"],
-        policy=row["policy"],
     )
 
 
@@ -146,18 +136,9 @@ class RegistryStore(DbStore):
         bottle_id: str | None = None,
         identity_token: str | None = None,
         metadata: str = "",
-        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,
@@ -165,18 +146,12 @@ class RegistryStore(DbStore):
             state="active",
             created_at=time.time(),
             metadata=metadata,
-            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) "
-                "VALUES (?, ?, ?, ?, ?, ?, ?)",
+                "(bottle_id, source_ip, identity_token, state, created_at, metadata) "
+                "VALUES (?, ?, ?, ?, ?, ?)",
                 (
                     rec.bottle_id,
                     rec.source_ip,
@@ -184,23 +159,11 @@ class RegistryStore(DbStore):
                     rec.state,
                     rec.created_at,
                     rec.metadata,
-                    rec.policy,
                 ),
             )
         self._chmod()
         return rec
 
-    def set_policy(self, bottle_id: str, policy: str) -> bool:
-        """Update a bottle's policy in place (live reload). Returns True if
-        the bottle exists."""
-        with self._connect() as conn:
-            cur = conn.execute(
-                "UPDATE orchestrator_bottles SET policy = ? WHERE bottle_id = ?",
-                (policy, bottle_id),
-            )
-        self._chmod()
-        return cur.rowcount > 0
-
     def deregister(self, bottle_id: str) -> bool:
         """Remove a bottle. Returns True if a row was deleted."""
         with self._connect() as conn:
@@ -225,13 +188,14 @@ class RegistryStore(DbStore):
             ).fetchall()
         return [_row_to_record(r) for r in rows]
 
-    def by_source_ip(self, source_ip: str) -> BottleRecord | None:
-        """Network-layer attribution: the single active bottle at this source
-        IP, or None if unknown or ambiguous (more than one — a
-        misconfiguration). Safe as the *sole* attributor only where the
-        source IP is unspoofable (Firecracker `/31` + nft) and the control
-        plane is reachable only by the trusted gateway; pair with the
-        identity token (`attribute`) elsewhere."""
+    def attribute(self, source_ip: str, identity_token: str) -> BottleRecord | None:
+        """Fail-closed attribution. Returns the bottle only when exactly one
+        active record has this source IP AND its identity token matches
+        (constant-time). Either signal alone is insufficient: an unknown IP,
+        an ambiguous IP (more than one active bottle — a misconfiguration),
+        an empty token, or a token mismatch all deny."""
+        if not identity_token:
+            return None
         with self._connect() as conn:
             rows = conn.execute(
                 "SELECT * FROM orchestrator_bottles "
@@ -240,17 +204,7 @@ class RegistryStore(DbStore):
             ).fetchall()
         if len(rows) != 1:
             return None
-        return _row_to_record(rows[0])
-
-    def attribute(self, source_ip: str, identity_token: str) -> BottleRecord | None:
-        """Fail-closed attribution: `by_source_ip` AND a matching identity
-        token (constant-time). Either signal alone is insufficient here — an
-        unknown/ambiguous IP, an empty token, or a token mismatch all deny."""
-        if not identity_token:
-            return None
-        rec = self.by_source_ip(source_ip)
-        if rec is None:
-            return None
+        rec = _row_to_record(rows[0])
         if not hmac.compare_digest(rec.identity_token, identity_token):
             return None
         return rec

bot_bottle/orchestrator/service.py

@@ -19,12 +19,12 @@ from __future__ import annotations
 
 from .broker import LaunchBroker, LaunchRequest, sign_request
 from .registry import BottleRecord, RegistryStore
-from .gateway import Gateway
+from .sidecar import Sidecar
 
 
 class Orchestrator:
     """Owns the registry + brokers launches, and manages the single
-    consolidated per-host gateway. Backend-neutral (broker and gateway
+    consolidated per-host sidecar. Backend-neutral (broker and sidecar
     abstract the backend-native pieces)."""
 
     def __init__(
@@ -32,18 +32,12 @@ class Orchestrator:
         registry: RegistryStore,
         broker: LaunchBroker,
         sign_secret: bytes,
-        gateway: Gateway | None = None,
+        sidecar: Sidecar | None = None,
     ) -> None:
         self.registry = registry
         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]] = {}
+        self._sidecar = sidecar
 
     def launch_bottle(
         self,
@@ -52,15 +46,10 @@ class Orchestrator:
         image_ref: str = "",
         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."""
-        rec = self.registry.register(source_ip, metadata=metadata, policy=policy)
-        if tokens:
-            self._tokens[rec.bottle_id] = dict(tokens)
+        """Register a bottle 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)
         req = LaunchRequest(
             op="launch",
             bottle_id=rec.bottle_id,
@@ -75,7 +64,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,52 +74,29 @@ 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)
 
-    def resolve(self, source_ip: str, identity_token: str = "") -> BottleRecord | None:
-        """Resolve the bottle behind a request — the source-IP-keyed lookup
-        the multi-tenant gateway makes per request; the returned record
-        carries its `policy`. With a token, full attribution (source IP +
-        token); without, network-layer attribution by source IP alone
-        (valid where the IP is unspoofable and the control plane is
-        gateway-only)."""
-        if identity_token:
-            return self.registry.attribute(source_ip, identity_token)
-        return self.registry.by_source_ip(source_ip)
+    # --- consolidated sidecar ----------------------------------------------
 
-    def set_policy(self, bottle_id: str, policy: str) -> bool:
-        """Update a bottle's gateway policy in place (live reload). False if
-        the bottle is unknown."""
-        return self.registry.set_policy(bottle_id, policy)
+    def ensure_sidecar(self) -> None:
+        """Ensure the single per-host sidecar is built and up (idempotent).
+        No-op when no sidecar is configured."""
+        if self._sidecar is not None:
+            self._sidecar.ensure_built()
+            self._sidecar.ensure_running()
 
-    # --- consolidated gateway ----------------------------------------------
-
-    def ensure_gateway(self) -> None:
-        """Ensure the single per-host gateway is built and up (idempotent).
-        No-op when no gateway is configured."""
-        if self._gateway is not None:
-            self._gateway.ensure_built()
-            self._gateway.ensure_running()
-
-    def gateway_status(self) -> dict[str, object]:
-        """Report the shared gateway for the control plane / console."""
-        if self._gateway is None:
+    def sidecar_status(self) -> dict[str, object]:
+        """Report the shared sidecar for the control plane / console."""
+        if self._sidecar is None:
             return {"configured": False}
         return {
             "configured": True,
-            "name": self._gateway.name,
-            "running": self._gateway.is_running(),
+            "name": self._sidecar.name,
+            "running": self._sidecar.is_running(),
         }
 
 

bot_bottle/orchestrator/sidecar.py

@@ -0,0 +1,139 @@
+"""The consolidated per-host sidecar (PRD 0070).
+
+The core consolidation win: **one** persistent sidecar per host, shared by
+every bottle, instead of a sidecar bundle per bottle. It's safe to share
+because the attribution invariant (source IP + identity token, see
+`registry`) lets the sidecar attribute each request to the right bottle —
+so per-bottle policy lives in one long-lived process keyed on who's calling.
+
+`Sidecar` is the backend-neutral lifecycle contract (mirrors `LaunchBroker`):
+ensure the single instance is up, report it, tear it down. `DockerSidecar`
+is the docker implementation; a firecracker sidecar VM slots in later.
+
+The defining behaviour is **idempotent singleton**: `ensure_running` starts
+the instance if absent and is a no-op if it's already up, so N bottle
+launches never spawn N sidecars.
+"""
+
+from __future__ import annotations
+
+import abc
+import os
+from pathlib import Path
+
+from ..docker_cmd import run_docker
+
+SIDECAR_NAME = "bot-bottle-orch-sidecar"
+SIDECAR_LABEL = "bot-bottle-orch-sidecar=1"
+
+# The real sidecar-bundle image + its Dockerfile. Kept as a local constant
+# rather than imported from backend.docker.sidecar_bundle, which would drag
+# the whole backend layer into the lean orchestrator (see #359); unify when
+# that lands. Env override matches the backend's BOT_BOTTLE_SIDECAR_IMAGE.
+SIDECAR_BUNDLE_IMAGE = os.environ.get("BOT_BOTTLE_SIDECAR_IMAGE", "bot-bottle-sidecars:latest")
+SIDECAR_DOCKERFILE = "Dockerfile.sidecars"
+_REPO_ROOT = Path(__file__).resolve().parents[2]
+
+
+class SidecarError(Exception):
+    """The shared sidecar failed to build/start/stop (non-zero `docker` exit)."""
+
+
+class Sidecar(abc.ABC):
+    """Lifecycle of the single per-host sidecar. Backend-neutral."""
+
+    name: str
+
+    def ensure_built(self) -> None:
+        """Ensure the sidecar's image / rootfs exists, building it if needed.
+        Default: nothing to build (e.g. a stub or a pre-pulled image)."""
+        return
+
+    @abc.abstractmethod
+    def ensure_running(self) -> None:
+        """Start the sidecar if it isn't already up. Idempotent: a no-op
+        when it's already running (that's the whole point — one per host).
+        Assumes the image exists — call `ensure_built()` first."""
+
+    @abc.abstractmethod
+    def is_running(self) -> bool:
+        """True iff the sidecar instance is currently up."""
+
+    @abc.abstractmethod
+    def stop(self) -> None:
+        """Remove the sidecar. Idempotent — absent is success."""
+
+
+class DockerSidecar(Sidecar):
+    """The consolidated sidecar as a single, fixed-name Docker container.
+
+    `image_ref` defaults to the real sidecar-bundle image; `ensure_built`
+    builds it from `Dockerfile.sidecars` when it's missing. (Note: slice 5
+    builds + launches the bundle container; wiring its per-bottle,
+    source-IP-keyed config is a later slice — see PRD 0070.)"""
+
+    def __init__(
+        self,
+        image_ref: str = SIDECAR_BUNDLE_IMAGE,
+        *,
+        name: str = SIDECAR_NAME,
+        build_context: Path | None = None,
+        dockerfile: str | None = SIDECAR_DOCKERFILE,
+    ) -> None:
+        self.image_ref = image_ref
+        self.name = name
+        self._build_context = build_context or _REPO_ROOT
+        self._dockerfile = dockerfile
+
+    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 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
+        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 SidecarError(f"sidecar image build failed: {proc.stderr.strip()}")
+
+    def is_running(self) -> bool:
+        proc = run_docker([
+            "docker", "ps",
+            "--filter", f"name=^{self.name}$",
+            "--filter", "status=running",
+            "--format", "{{.Names}}",
+        ])
+        return self.name in proc.stdout.split()
+
+    def ensure_running(self) -> None:
+        if self.is_running():
+            return
+        # 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])
+        proc = run_docker([
+            "docker", "run", "--detach",
+            "--name", self.name,
+            "--label", SIDECAR_LABEL,
+            self.image_ref,
+        ])
+        if proc.returncode != 0:
+            raise SidecarError(f"sidecar failed to start: {proc.stderr.strip()}")
+
+    def stop(self) -> None:
+        proc = run_docker(["docker", "rm", "--force", self.name])
+        if proc.returncode != 0 and "No such container" not in proc.stderr:
+            raise SidecarError(f"sidecar failed to stop: {proc.stderr.strip()}")
+
+
+__all__ = [
+    "Sidecar", "DockerSidecar", "SidecarError",
+    "SIDECAR_NAME", "SIDECAR_LABEL", "SIDECAR_BUNDLE_IMAGE",
+]

bot_bottle/policy_resolver.py

@@ -1,128 +0,0 @@
-"""Gateway-side per-client policy resolver (PRD 0070).
-
-The consolidated gateway serves every bottle from one process, so for each
-request it must apply the *calling* bottle's policy, selected by the source
-IP the attribution invariant makes unspoofable. This resolves that policy
-from the orchestrator's control plane (`POST /resolve`), keyed on the
-`(source_ip, identity_token)` pair.
-
-**Always fresh — no cache.** The resolver is called rarely enough that a
-round-trip doesn't matter, and correctness matters more than speed: every
-resolve reflects the orchestrator's *current* view, so a revocation, a
-policy change, or a bottle teardown the orchestrator knows about is honored
-immediately rather than lingering for a cache TTL. (If this ever becomes a
-hot path, add caching with orchestrator-driven invalidation — not a blind
-TTL.)
-
-**Fail-closed:** an unattributed client (the orchestrator answers `403`)
-resolves to `None`, and the caller (the egress addon, git-gate) must then
-deny — exactly as an unknown bottle should be treated. Orchestrator
-*errors* (unreachable / unexpected status) raise, so the caller can fail
-closed too rather than silently serving stale or empty policy.
-
-The resolved value is the policy blob the orchestrator stores verbatim; the
-consumer parses it (e.g. the egress addon's `load_config`). This module is
-stdlib-only and free of bot-bottle imports so it can be COPYed flat into
-the sidecar bundle.
-"""
-
-from __future__ import annotations
-
-import json
-import urllib.error
-import urllib.request
-
-DEFAULT_TIMEOUT_SECONDS = 2.0
-
-
-class PolicyResolveError(RuntimeError):
-    """The orchestrator was unreachable or returned an unexpected status —
-    distinct from a clean `403` (unattributed), which returns None."""
-
-
-class PolicyResolver:
-    """Resolves each client's policy from the orchestrator, fresh per call."""
-
-    def __init__(self, base_url: str, *, timeout: float = DEFAULT_TIMEOUT_SECONDS) -> None:
-        self._base = base_url.rstrip("/")
-        self._timeout = timeout
-
-    def _post_resolve(self, source_ip: str, identity_token: str) -> dict[str, object] | None:
-        """The orchestrator's `/resolve` payload for this client, or None if
-        unattributed (a clean `403`). Raises `PolicyResolveError` on an
-        unreachable / unexpected-status / malformed response so every caller
-        can fail closed. Shared by `resolve` and `resolve_bottle_id`."""
-        body = json.dumps(
-            {"source_ip": source_ip, "identity_token": identity_token}
-        ).encode()
-        req = urllib.request.Request(
-            f"{self._base}/resolve", data=body, method="POST",
-            headers={"Content-Type": "application/json"},
-        )
-        try:
-            with urllib.request.urlopen(req, timeout=self._timeout) as resp:
-                payload = json.loads(resp.read())
-        except urllib.error.HTTPError as e:
-            if e.code == 403:
-                return None  # unattributed → fail closed (caller denies)
-            raise PolicyResolveError(f"/resolve returned HTTP {e.code}") from e
-        except (urllib.error.URLError, TimeoutError, OSError, ValueError) as e:
-            raise PolicyResolveError(f"/resolve unreachable or malformed: {e}") from e
-        return payload if isinstance(payload, dict) else {}
-
-    def resolve(self, source_ip: str, identity_token: str = "") -> str | None:
-        """The calling bottle's policy blob, or None if unattributed. Always
-        fetches from the orchestrator so revocations / changes / teardowns
-        are honored immediately.
-
-        `identity_token` is optional *transitionally* — omitting it resolves
-        by source IP alone (the network-layer attribution, sound by
-        construction on Firecracker's `/31`+nft, weaker elsewhere). The
-        consolidated end state makes the token mandatory so the app-layer
-        defense is always enforced, not silently degraded; that flips at the
-        `/resolve` boundary once identity-token *delivery* lands (a PRD 0070
-        open question — we can't require what the agent can't yet present).
-        Raises `PolicyResolveError` if the orchestrator can't be reached."""
-        payload = self._post_resolve(source_ip, identity_token)
-        if payload is None:
-            return None
-        policy = payload.get("policy")
-        return policy if isinstance(policy, str) else ""
-
-    def resolve_bottle_id(self, source_ip: str, identity_token: str = "") -> str | None:
-        """The calling bottle's id, or None if unattributed. This is the
-        source-IP-keyed identity the git-gate uses to select the bottle's
-        repo namespace (there is no per-bottle policy blob to parse — the
-        bottle *is* the namespace). Same fail-closed contract as `resolve`."""
-        payload = self._post_resolve(source_ip, identity_token)
-        if payload is None:
-            return None
-        bottle_id = payload.get("bottle_id")
-        return bottle_id if isinstance(bottle_id, str) and bottle_id else None
-
-    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."""
-        payload = self._post_resolve(source_ip, identity_token)
-        if payload is 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,
-        )
-
-
-__all__ = ["PolicyResolver", "PolicyResolveError"]

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/prds/0070-per-host-orchestrator.md

@@ -10,8 +10,8 @@
 
 ## Summary
 
-Replace the **per-bottle gateway bundle** with a single **persistent,
-per-host orchestrator**: one long-lived service that runs the gateway
+Replace the **per-bottle sidecar bundle** with a single **persistent,
+per-host orchestrator**: one long-lived service that runs the sidecar
 functions (egress / git-gate / supervise), coordinates with the console,
 and brokers agent launches and teardown. It is **virtualized from the
 start** using each backend's native isolation primitive — a Firecracker
@@ -22,13 +22,13 @@ container on the legacy backend — and is fronted by a single
 
 ## Motivation
 
-Today each bottle spins up its own gateway bundle (egress mitmproxy +
+Today each bottle spins up its own sidecar bundle (egress mitmproxy +
 git-gate + supervise). That costs:
 
 - **Resources.** N bottles → N heavy bundles booting and idling.
 - **Operational churn.** Per-launch container/VM lifecycle for the
-  gateways, a control path baked at launch and torn down at exit.
-- **A blurry contract.** "How a bottle talks to its gateway" is
+  sidecars, a control path baked at launch and torn down at exit.
+- **A blurry contract.** "How a bottle talks to its sidecar" is
   re-implemented per backend instead of being one agreed interface.
 
 A per-host orchestrator collapses the first two and forces the third to
@@ -52,11 +52,11 @@ weaken, and the weakened ones must be mitigated by design, not hand-waved.
   structured, auditable privileged core instead of a fat socket.
 - **Attribution is enforced, not assumed.** Making source-IP identity a
   first-class contract invariant (below) means each backend must *prove*
-  it, rather than the gateway implicitly trusting network position.
+  it, rather than the sidecar implicitly trusting network position.
 
 ### What gets weaker, and the mitigation
 
-1. **Secret concentration.** Per-bottle gateways isolate secrets at the
+1. **Secret concentration.** Per-bottle sidecars isolate secrets at the
    process boundary — each holds only its bottle's tokens/keys. A host
    orchestrator concentrates **every bottle's** egress tokens, git deploy
    keys, and the console credential in one long-lived process. A single
@@ -75,7 +75,7 @@ weaken, and the weakened ones must be mitigated by design, not hand-waved.
    fleet, plus launch authority, plus the console token.
    - *Mitigation:* the orchestrator is itself confined (its own VM/container
      with its own fail-closed egress); make it **restartable without killing
-     running agent VMs** (agents keep running; they briefly lose gateway
+     running agent VMs** (agents keep running; they briefly lose sidecar
      connectivity until it's back); persist state to a host volume so a
      restart re-adopts live bottles rather than losing them.
 
@@ -114,13 +114,13 @@ responsibility** and part of the contract:
 - **Apple** — the host-only network.
 
 If a backend can't honor the invariant, source-IP consolidation is not
-safe there and that backend keeps per-bottle gateways. The invariant is a
+safe there and that backend keeps per-bottle sidecars. The invariant is a
 hard precondition, not an aspiration.
 
 **Defense-in-depth — a per-bottle identity token.** On top of the
 network-layer invariant, inject a per-bottle secret token into every
 request the agent makes to the orchestrator (the agent already egresses
-through the gateway proxy, so this is cheap to add). It gives an
+through the sidecar proxy, so this is cheap to add). It gives an
 **application-layer** proof of identity independent of the network layer:
 
 - On **Firecracker** the `/31` + nft already make source IP unspoofable
@@ -133,7 +133,7 @@ Requirements: the token is **per-bottle, unguessable, and
 non-cross-leakable** — a bottle can only ever prove it is *itself* (it
 can't learn another bottle's token, given bottle isolation), so a hostile
 agent gains nothing by presenting it. The orchestrator provisions the
-token at launch and the gateway requires it to attribute + authorize.
+token at launch and the sidecar requires it to attribute + authorize.
 Note this hardens *attribution*, not *secret exposure*: it's app-layer, so
 a compromised orchestrator still sees every token (that's the
 concentration problem, addressed separately under Secret handling).
@@ -178,7 +178,7 @@ manifest anywhere a raw token value is accepted, discovered from
 `AgentProvider`s are — because maintaining every forge/cloud/OAuth
 provider in-tree is untenable. The orchestrator's vault mints via these
 providers; but the abstraction is shippable independently and today's
-per-bottle gateways can use it too.
+per-bottle sidecars can use it too.
 
 ## Design
 
@@ -195,7 +195,7 @@ Three surfaces; only one is per-backend.
    every host (no vsock/unix-socket portability caveats); a local unix
    socket is a fine optimization, but HTTP is the wire contract.
 2. **Data plane (agent → orchestrator)** — the egress / git / supervise
-   endpoints. Already agnostic today (agents dial `http://gateway:9099`);
+   endpoints. Already agnostic today (agents dial `http://sidecar:9099`);
    only the *address* and *how packets get there* are per-backend.
 3. **Launch / wire (orchestrator → backend)** — the irreducibly
    backend-specific part; lives on `BottleBackend`.
@@ -249,7 +249,7 @@ forged one from a compromised co-located component. The orchestrator signs;
 the broker verifies with the orchestrator's public key (provisioned at
 broker install). This is the concrete form of security #3's "structured
 requests only." Same JSON-with-ids + JWT shape for all
-orchestrator↔broker/gateway communication; cases that don't fit get
+orchestrator↔broker/sidecar communication; cases that don't fit get
 handled as they arise, with this as the default.
 
 If `BottleBackend` bloats, the pressure valve is composition one level
@@ -299,10 +299,10 @@ and integrate a console against.
   the data plane and the console reach state through the control-plane RPC,
   never a direct file handle.** No agent-facing component gets the file, so
   none can forge attribution. (This supersedes the earlier `ro`-mount idea.)
-  - *Transitional caveat:* today the per-bottle **supervise gateway
+  - *Transitional caveat:* today the per-bottle **supervise sidecar
     rw-bind-mounts `bot-bottle.db`** to write proposals — exactly the
     pattern the orchestrator removes (supervise consolidates into the
-    orchestrator; gateway writes become RPC calls). Until that lands, don't
+    orchestrator; sidecar writes become RPC calls). Until that lands, don't
     put the attribution registry behind a data-plane-writable mount.
 
 Implementation note for the VM slices: SQLite **WAL** over a guest share
@@ -327,7 +327,7 @@ orchestrator becomes a VM. Decouple the two risks instead:
 
 Backend order (cheapest proof → hardest → last):
 
-1. **Docker orchestrator** — nearly free (the gateway bundle is already
+1. **Docker orchestrator** — nearly free (the sidecar bundle is already
    containers; collapse N bundles into one persistent container). Proves
    consolidation + the `BottleBackend` seam with the least moving parts.
 2. **Firecracker orchestrator** — the real work: the shim + VM-to-VM
@@ -336,13 +336,13 @@ Backend order (cheapest proof → hardest → last):
    the dev-harness so the app logic is already proven.
 3. **macOS (Apple container)** — last (container-to-container networking).
 
-Keep the gateway **service one shared thing** throughout.
+Keep the sidecar **service one shared thing** throughout.
 
 ## Non-goals
 
 - Removing OCI/Dockerfile support for agent images (0069's concern).
 - A single database for *all* config (see the three-tier table).
-- Changing the per-bottle isolation of agent workloads — only the gateway
+- Changing the per-bottle isolation of agent workloads — only the sidecar
   is consolidated; agents stay one-VM/container-each.
 
 ## Relationship to other work
@@ -393,7 +393,7 @@ Keep the gateway **service one shared thing** throughout.
   `BottleBackend.wire()` (DNAT+forward for fc, shared-net for
   docker/apple), not orchestrator logic. **Not a blocker** — resolvable at
   implementation time (may require a bit of host modification, as the pool
-  setup already does on NixOS); an earlier "gateways in VMs" spike showed
+  setup already does on NixOS); an earlier "sidecars in VMs" spike showed
   it's feasible.
 - **Live-reload protocol** for per-bottle policy over the HTTP control
   plane (add/remove routes/keys/proposals without a restart).

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/integration/test_orchestrator_docker_sidecar.py

@@ -1,7 +1,7 @@
-"""Integration: the consolidated Docker gateway is an idempotent singleton.
+"""Integration: the consolidated Docker sidecar is an idempotent singleton.
 
 Gated on a reachable Docker daemon. Uses a unique name so it never
-collides with a real per-host gateway or a leftover from another run.
+collides with a real per-host sidecar or a leftover from another run.
 """
 
 from __future__ import annotations
@@ -10,17 +10,17 @@ import secrets
 import subprocess
 import unittest
 
-from bot_bottle.orchestrator.gateway import DockerGateway
+from bot_bottle.orchestrator.sidecar import DockerSidecar
 from tests._docker import skip_unless_docker
 
 IMAGE = "busybox"
 
 
 @skip_unless_docker()
-class TestDockerGatewayIntegration(unittest.TestCase):
+class TestDockerSidecarIntegration(unittest.TestCase):
     def setUp(self) -> None:
-        self.name = "bot-bottle-orch-gateway-itest-" + secrets.token_hex(4)
-        self.sc = DockerGateway(IMAGE, name=self.name)
+        self.name = "bot-bottle-orch-sidecar-itest-" + secrets.token_hex(4)
+        self.sc = DockerSidecar(IMAGE, name=self.name)
         self.addCleanup(self.sc.stop)
 
     def _count(self) -> int:

tests/integration/test_orchestrator_docker_sidecar_build.py

@@ -1,4 +1,4 @@
-"""Integration: DockerGateway.image_exists reflects real docker state.
+"""Integration: DockerSidecar.image_exists reflects real docker state.
 
 Gated on a reachable Docker daemon. Deliberately does NOT build the full
 sidecar bundle (a heavy, slow image build) — it exercises the `image_exists`
@@ -11,14 +11,14 @@ from __future__ import annotations
 import subprocess
 import unittest
 
-from bot_bottle.orchestrator.gateway import DockerGateway
+from bot_bottle.orchestrator.sidecar import DockerSidecar
 from tests._docker import skip_unless_docker
 
 IMAGE = "busybox"
 
 
 @skip_unless_docker()
-class TestDockerGatewayImageExists(unittest.TestCase):
+class TestDockerSidecarImageExists(unittest.TestCase):
     def test_image_exists_true_for_present_false_for_absent(self) -> None:
         # Ensure the tiny image is present (build_if_missing is disabled here
         # so this never triggers a Dockerfile.sidecars build).
@@ -26,9 +26,9 @@ class TestDockerGatewayImageExists(unittest.TestCase):
             ["docker", "pull", IMAGE],
             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False,
         )
-        self.assertTrue(DockerGateway(IMAGE, dockerfile=None).image_exists())
+        self.assertTrue(DockerSidecar(IMAGE, dockerfile=None).image_exists())
         self.assertFalse(
-            DockerGateway("bot-bottle-nonexistent:doesnotexist", dockerfile=None).image_exists()
+            DockerSidecar("bot-bottle-nonexistent:doesnotexist", dockerfile=None).image_exists()
         )
 
 

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,111 +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, "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,36 +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, "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_log_redaction.py

@@ -46,7 +46,7 @@ def _addon() -> EgressAddon:
     """Return a bare EgressAddon with LOG_FULL config and no routes file."""
     a: EgressAddon = EgressAddon.__new__(EgressAddon)
     a.config = Config(routes=(), log=LOG_FULL)
-    a._safe_tokens = {}
+    a.safe_tokens = set()
     a._supervise_slug = ""
     a._token_allow_timeout = 300.0
     return a

tests/unit/test_egress_addon_request_flow.py

@@ -211,7 +211,7 @@ def _addon(config: Config) -> EgressAddon:
     """Bare EgressAddon with a supplied config and no supervise wiring."""
     a: EgressAddon = EgressAddon.__new__(EgressAddon)
     a.config = config
-    a._safe_tokens = {}
+    a.safe_tokens = set()
     a._supervise_slug = ""
     a._token_allow_timeout = 300.0
     a.routes_path = "/nonexistent/routes.yaml"
@@ -222,32 +222,6 @@ def _run_request(addon: EgressAddon, flow: _Flow) -> None:
     asyncio.run(addon.request(flow))  # type: ignore[arg-type]
 
 
-def _with_client_ip(flow: _Flow, ip: str) -> _Flow:
-    """Attach a mitmproxy-style client_conn so consolidated resolution can read
-    the source IP (`flow.client_conn.peername[0]`)."""
-    flow.client_conn = types.SimpleNamespace(peername=(ip, 54321))  # type: ignore[attr-defined]
-    return flow
-
-
-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:
-        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]]:
-        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 {})
-
-
 # ---------------------------------------------------------------------------
 # Introspection endpoint
 # ---------------------------------------------------------------------------
@@ -444,8 +418,7 @@ class TestSuperviseBranch(unittest.TestCase):
         with patch.object(_ea_mod, "_sv", _fake_sv("approved")):
             _run_request(addon, flow)
         self.assertIsNone(flow.response)  # forwarded after approval
-        # Approval lands in the calling bottle's safelist (keyed by slug).
-        self.assertIn(_OPENAI_KEY, addon._safe_tokens_for("test-bottle"))
+        self.assertIn(_OPENAI_KEY, addon.safe_tokens)
 
     def test_operator_rejection_blocks(self) -> None:
         addon = self._supervised_addon()
@@ -762,102 +735,5 @@ class TestLogFullRequest(unittest.TestCase):
         self.assertTrue(any(e.get("event") == "egress_request" for e in logged))
 
 
-class TestSuperviseMultiTenant(unittest.TestCase):
-    """Consolidated gateway: supervise proposals + the DLP safelist are keyed
-    per bottle, resolved by source IP (PRD 0070)."""
-
-    def _consolidated_addon(self) -> EgressAddon:
-        # Static config is empty; the resolver supplies each bottle's config.
-        addon = _addon(Config(routes=()))
-        addon._resolver = cast(Any, _CtxResolver({"10.0.0.1": "bottle-a", "10.0.0.2": "bottle-b"}))
-        addon._token_allow_timeout = 0.05
-        return addon
-
-    def test_approval_is_scoped_to_the_calling_bottle(self) -> None:
-        addon = self._consolidated_addon()
-        # bottle-a (10.0.0.1) sends the token; the operator approves.
-        flow = _with_client_ip(
-            _Flow(_Request(host="api.example.com", method="POST", body=f"k={_OPENAI_KEY}")),
-            "10.0.0.1",
-        )
-        with patch.object(_ea_mod, "_sv", _fake_sv("approved")):
-            _run_request(addon, flow)
-        self.assertIsNone(flow.response)  # forwarded after approval
-        # The approval lands ONLY in bottle-a's safelist — never bottle-b's.
-        # A global set here would be the cross-tenant leak this slice closes.
-        self.assertIn(_OPENAI_KEY, addon._safe_tokens_for("bottle-a"))
-        self.assertNotIn(_OPENAI_KEY, addon._safe_tokens_for("bottle-b"))
-
-    def test_proposal_is_attributed_to_the_source_ip_bottle(self) -> None:
-        addon = self._consolidated_addon()
-        seen: list[str] = []
-        fake = _fake_sv("approved")
-
-        def _capture(**kw: Any) -> Any:
-            seen.append(kw["bottle_slug"])
-            return types.SimpleNamespace(id="p")
-
-        fake.Proposal = types.SimpleNamespace(new=_capture)
-        flow = _with_client_ip(
-            _Flow(_Request(host="api.example.com", method="POST", body=f"k={_OPENAI_KEY}")),
-            "10.0.0.2",
-        )
-        with patch.object(_ea_mod, "_sv", fake):
-            _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.
-        flow = _with_client_ip(
-            _Flow(_Request(host="api.example.com", method="POST", body=f"k={_OPENAI_KEY}")),
-            "10.9.9.9",
-        )
-        with patch.object(_ea_mod, "_sv", _fake_sv("approved")):
-            _run_request(addon, flow)
-        self.assertIsNotNone(flow.response)  # blocked (no route, no supervise)
-        self.assertNotIn(_OPENAI_KEY, addon._safe_tokens_for(""))
-
-
 if __name__ == "__main__":
     unittest.main()

tests/unit/test_egress_multitenant.py

@@ -1,110 +0,0 @@
-"""Unit: fail-closed per-client egress resolution — config + context (PRD 0070)."""
-
-from __future__ import annotations
-
-import unittest
-
-from bot_bottle.egress_addon_core import resolve_client_config, resolve_client_context
-from bot_bottle.policy_resolver import PolicyResolveError
-
-
-class _FakeResolver:
-    def __init__(self, result: str | None = None, raises: bool = False) -> None:
-        self._result = result
-        self._raises = raises
-        self.calls: list[tuple[str, str]] = []
-
-    def resolve(self, source_ip: str, identity_token: str = "") -> str | None:
-        self.calls.append((source_ip, identity_token))
-        if self._raises:
-            raise PolicyResolveError("orchestrator down")
-        return self._result
-
-
-class TestResolveClientConfig(unittest.TestCase):
-    def test_valid_policy_is_parsed(self) -> None:
-        cfg = resolve_client_config(
-            _FakeResolver(result="routes:\n  - host: example.com\n"), "10.243.0.1"
-        )
-        self.assertEqual(("example.com",), tuple(r.host for r in cfg.routes))
-
-    def test_unattributed_none_denies_all(self) -> None:
-        cfg = resolve_client_config(_FakeResolver(result=None), "10.243.0.9")
-        self.assertEqual((), cfg.routes)  # no routes → default-deny
-
-    def test_empty_policy_denies_all(self) -> None:
-        self.assertEqual((), resolve_client_config(_FakeResolver(result=""), "10.243.0.1").routes)
-
-    def test_resolver_error_denies_all(self) -> None:
-        # Orchestrator unreachable/errored must never widen egress.
-        self.assertEqual((), resolve_client_config(_FakeResolver(raises=True), "10.243.0.1").routes)
-
-    def test_unparseable_policy_denies_all(self) -> None:
-        cfg = resolve_client_config(_FakeResolver(result="routes: notalist\n"), "10.243.0.1")
-        self.assertEqual((), cfg.routes)
-
-    def test_forwards_source_ip_and_token(self) -> None:
-        r = _FakeResolver(result=None)
-        resolve_client_config(r, "10.243.0.1", "tok")
-        self.assertEqual(("10.243.0.1", "tok"), r.calls[0])
-
-
-class _FakeContextResolver:
-    def __init__(
-        self, policy: str | None = None, bottle_id: str | None = None,
-        raises: bool = False, tokens: dict[str, str] | None = None,
-    ) -> 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]]:
-        if self._raises:
-            raise PolicyResolveError("orchestrator down")
-        return self._policy, self._bottle_id, self._tokens
-
-
-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"},
-            ),
-            "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(
-            _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",
-        )
-        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(
-            _FakeContextResolver(policy="routes: notalist\n", bottle_id="b2"), "10.243.0.1",
-        )
-        self.assertEqual((), cfg.routes)
-        self.assertEqual("b2", slug)
-
-
-if __name__ == "__main__":
-    unittest.main()

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_git_http_multitenant.py

@@ -1,65 +0,0 @@
-"""Unit: resolve_sandbox_root — source-IP-keyed git-gate repo namespace (PRD 0070).
-
-The consolidated git-http backend serves every bottle from one process and
-selects each request's repo root by the calling bottle's source IP. This is
-the fail-closed selection logic, tested without a live server.
-"""
-
-from __future__ import annotations
-
-import unittest
-from pathlib import Path
-
-from bot_bottle.git_http_backend import resolve_sandbox_root
-from bot_bottle.policy_resolver import PolicyResolveError
-
-_BASE = Path("/git")
-
-
-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[tuple[str, str]] = []
-
-    def resolve_bottle_id(self, source_ip: str, identity_token: str = "") -> str | None:
-        self.calls.append((source_ip, identity_token))
-        if self._raises:
-            raise PolicyResolveError("orchestrator down")
-        return self._bottle_id
-
-
-class TestResolveRepoRoot(unittest.TestCase):
-    def test_single_tenant_passthrough(self) -> None:
-        # No resolver → the flat base root, unchanged (legacy per-bottle mode).
-        self.assertEqual(_BASE, resolve_sandbox_root(None, _BASE, "10.243.0.1"))
-
-    def test_attributed_bottle_gets_namespaced_root(self) -> None:
-        root = resolve_sandbox_root(_FakeResolver(bottle_id="ab12cd34"), _BASE, "10.243.0.1")
-        self.assertEqual(Path("/git/ab12cd34"), root)
-
-    def test_unattributed_denies(self) -> None:
-        self.assertIsNone(resolve_sandbox_root(_FakeResolver(bottle_id=None), _BASE, "10.243.0.9"))
-
-    def test_empty_bottle_id_denies(self) -> None:
-        self.assertIsNone(resolve_sandbox_root(_FakeResolver(bottle_id=""), _BASE, "10.243.0.1"))
-
-    def test_resolver_error_denies(self) -> None:
-        # Orchestrator unreachable/errored must never serve repos.
-        self.assertIsNone(resolve_sandbox_root(_FakeResolver(raises=True), _BASE, "10.243.0.1"))
-
-    def test_namespace_escape_denies(self) -> None:
-        # A bottle_id that would climb out of the root is rejected (defense in
-        # depth — registry ids are token_hex, but never trust the namespace).
-        self.assertIsNone(
-            resolve_sandbox_root(_FakeResolver(bottle_id="../etc"), _BASE, "10.243.0.1")
-        )
-
-    def test_forwards_source_ip_and_token(self) -> None:
-        r = _FakeResolver(bottle_id="b1")
-        resolve_sandbox_root(r, _BASE, "10.243.0.1", "tok")
-        self.assertEqual(("10.243.0.1", "tok"), r.calls[0])
-
-
-if __name__ == "__main__":
-    unittest.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_control_plane.py

@@ -118,75 +118,11 @@ class TestDispatch(unittest.TestCase):
         status, _ = dispatch(self.orch, "GET", "/health/", b"")
         self.assertEqual(200, status)
 
-    def test_gateway_status_unconfigured(self) -> None:
-        status, payload = dispatch(self.orch, "GET", "/gateway", b"")
+    def test_sidecar_status_unconfigured(self) -> None:
+        status, payload = dispatch(self.orch, "GET", "/sidecar", b"")
         self.assertEqual(200, status)
         self.assertEqual(False, payload["configured"])
 
-    def test_launch_stores_policy_and_resolve_returns_it(self) -> None:
-        _, reg = dispatch(
-            self.orch, "POST", "/bottles",
-            _body({"source_ip": "10.243.0.5", "policy": '{"a":1}'}),
-        )
-        status, payload = dispatch(
-            self.orch, "POST", "/resolve",
-            _body({"source_ip": "10.243.0.5", "identity_token": reg["identity_token"]}),
-        )
-        self.assertEqual(200, status)
-        self.assertEqual(reg["bottle_id"], payload["bottle_id"])
-        self.assertEqual('{"a":1}', payload["policy"])
-
-    def test_resolve_forbidden_on_bad_token(self) -> None:
-        dispatch(self.orch, "POST", "/bottles", _body({"source_ip": "10.243.0.5"}))
-        status, _ = dispatch(
-            self.orch, "POST", "/resolve",
-            _body({"source_ip": "10.243.0.5", "identity_token": "nope"}),
-        )
-        self.assertEqual(403, status)
-
-    def test_put_policy_updates_live(self) -> None:
-        _, reg = dispatch(self.orch, "POST", "/bottles", _body({"source_ip": "10.243.0.1"}))
-        bid = reg["bottle_id"]
-        status, payload = dispatch(
-            self.orch, "PUT", f"/bottles/{bid}/policy", _body({"policy": '{"v":9}'})
-        )
-        self.assertEqual(200, status)
-        self.assertEqual(True, payload["updated"])
-        _, resolved = dispatch(
-            self.orch, "POST", "/resolve",
-            _body({"source_ip": "10.243.0.1", "identity_token": reg["identity_token"]}),
-        )
-        self.assertEqual('{"v":9}', resolved["policy"])
-
-    def test_put_policy_missing_bottle_404(self) -> None:
-        status, _ = dispatch(
-            self.orch, "PUT", "/bottles/ghost/policy", _body({"policy": "{}"})
-        )
-        self.assertEqual(404, status)
-
-    def test_put_policy_requires_string(self) -> None:
-        _, reg = dispatch(self.orch, "POST", "/bottles", _body({"source_ip": "10.243.0.1"}))
-        status, _ = dispatch(
-            self.orch, "PUT", f"/bottles/{reg['bottle_id']}/policy", _body({})
-        )
-        self.assertEqual(400, status)
-
-    def test_resolve_without_token_by_source_ip(self) -> None:
-        _, reg = dispatch(
-            self.orch, "POST", "/bottles",
-            _body({"source_ip": "10.243.0.5", "policy": "P"}),
-        )
-        status, payload = dispatch(
-            self.orch, "POST", "/resolve", _body({"source_ip": "10.243.0.5"})
-        )
-        self.assertEqual(200, status)
-        self.assertEqual(reg["bottle_id"], payload["bottle_id"])
-        self.assertEqual("P", payload["policy"])
-
-    def test_resolve_requires_source_ip(self) -> None:
-        status, _ = dispatch(self.orch, "POST", "/resolve", _body({}))
-        self.assertEqual(400, status)
-
 
 class TestServerRoundTrip(unittest.TestCase):
     def test_http_register_health_attribute(self) -> None:

tests/unit/test_orchestrator_gateway.py

@@ -1,215 +0,0 @@
-"""Unit tests for the consolidated Docker gateway (PRD 0070). Docker mocked."""
-
-from __future__ import annotations
-
-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"
-
-
-def _proc(returncode: int = 0, stdout: str = "", stderr: str = "") -> Mock:
-    return Mock(returncode=returncode, stdout=stdout, stderr=stderr)
-
-
-class TestDockerGateway(unittest.TestCase):
-    def setUp(self) -> None:
-        self.sc = DockerGateway("bot-bottle-sidecars:latest")
-
-    def test_default_name(self) -> None:
-        self.assertEqual(GATEWAY_NAME, self.sc.name)
-
-    def test_is_running_reads_docker_ps(self) -> None:
-        with patch(_RUN_DOCKER, return_value=_proc(stdout=self.sc.name + "\n")):
-            self.assertTrue(self.sc.is_running())
-        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):
-            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))
-
-    def test_ensure_running_starts_the_singleton_when_absent(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()
-
-        runs = [c for c in calls if c[:2] == ["docker", "run"]]
-        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:
-            if argv[:2] == ["docker", "ps"]:
-                return _proc(stdout="")
-            if argv[:2] == ["docker", "run"]:
-                return _proc(returncode=1, stderr="boom")
-            return _proc()
-
-        with patch(_RUN_DOCKER, side_effect=fake):
-            with self.assertRaises(GatewayError):
-                self.sc.ensure_running()
-
-    def test_stop_is_idempotent_on_missing(self) -> None:
-        absent = _proc(returncode=1, stderr="Error: No such container: x")
-        with patch(_RUN_DOCKER, return_value=absent):
-            self.sc.stop()  # must not raise
-
-    def test_stop_raises_on_other_failure(self) -> None:
-        with patch(_RUN_DOCKER, return_value=_proc(returncode=1, stderr="daemon down")):
-            with self.assertRaises(GatewayError):
-                self.sc.stop()
-
-
-class TestDockerGatewayBuild(unittest.TestCase):
-    def setUp(self) -> None:
-        self.sc = DockerGateway()  # defaults to the real bundle image + dockerfile
-
-    def test_image_exists_reads_docker_inspect(self) -> None:
-        with patch(_RUN_DOCKER, return_value=_proc(returncode=0)):
-            self.assertTrue(self.sc.image_exists())
-        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.
-        calls: list[list[str]] = []
-
-        def rec(argv: list[str]) -> Mock:
-            calls.append(argv)
-            return _proc()  # image present, build succeeds
-
-        with patch(_RUN_DOCKER, side_effect=rec):
-            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.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)
-        with patch(_RUN_DOCKER) as m:
-            sc.ensure_built()
-        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")):
-            with self.assertRaises(GatewayError):
-                self.sc.ensure_built()
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/test_orchestrator_lifecycle.py

@@ -1,140 +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,
-    ORCHESTRATOR_SOURCE_HASH_LABEL,
-    OrchestratorService,
-    OrchestratorStartError,
-    _source_hash,
-)
-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
-
-
-def _proc(returncode: int = 0, stdout: str = "", stderr: str = "") -> Mock:
-    return Mock(returncode=returncode, stdout=stdout, stderr=stderr)
-
-
-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_noop_when_healthy_and_source_unchanged(self) -> None:
-        # A healthy control plane already running the *current* bind-mounted
-        # source is left alone — recreating it on every launch would drop
-        # every other active bottle's in-memory egress tokens (#381).
-        current = _source_hash(self.svc._repo_root)
-        calls: list[list[str]] = []
-
-        def fake(argv: list[str]) -> Mock:
-            calls.append(argv)
-            if argv[:2] == ["docker", "ps"]:
-                return _proc(stdout=ORCHESTRATOR_NAME)
-            if argv[:2] == ["docker", "inspect"]:
-                return _proc(stdout=current)
-            return _proc()
-
-        with patch(_URLOPEN, return_value=_health(200)), \
-                patch(_GATEWAY) as gw_cls, patch(_RUN, side_effect=fake), patch(_SLEEP):
-            self.assertEqual(self.svc.url, self.svc.ensure_running())
-        gw_cls.return_value.ensure_running.assert_called()   # gateway kept up
-        runs = [c for c in calls if c[:2] == ["docker", "run"]]
-        rms = [c for c in calls if c[:3] == ["docker", "rm", "--force"] and ORCHESTRATOR_NAME in c]
-        self.assertEqual([], runs)   # not recreated
-        self.assertEqual([], rms)
-
-    def test_ensure_running_recreates_when_source_changed(self) -> None:
-        # Healthy, but the running container's label doesn't match the
-        # current source hash (a real code change) — recreate so it takes
-        # effect, same as the gateway's image-staleness check.
-        calls: list[list[str]] = []
-
-        def fake(argv: list[str]) -> Mock:
-            calls.append(argv)
-            if argv[:2] == ["docker", "ps"]:
-                return _proc(stdout=ORCHESTRATOR_NAME)
-            if argv[:2] == ["docker", "inspect"]:
-                return _proc(stdout="stale-hash")
-            return _proc()
-
-        with patch(_URLOPEN, return_value=_health(200)), \
-                patch(_GATEWAY), patch(_RUN, side_effect=fake), patch(_SLEEP):
-            self.assertEqual(self.svc.url, self.svc.ensure_running())
-        runs = [c for c in calls if c[:2] == ["docker", "run"]]
-        self.assertEqual(1, len(runs))
-        self.assertIn(ORCHESTRATOR_NAME, runs[0])
-        # the fresh container is labeled with the current hash, not the stale one
-        current = _source_hash(self.svc._repo_root)
-        self.assertIn(f"{ORCHESTRATOR_SOURCE_HASH_LABEL}={current}", runs[0])
-
-    def test_ensure_running_starts_orchestrator_container_when_absent(self) -> None:
-        calls: list[list[str]] = []
-
-        def fake(argv: list[str]) -> Mock:
-            calls.append(argv)
-            if argv[:2] == ["docker", "ps"]:
-                return _proc(stdout="")   # not running
-            return _proc()
-
-        with patch(_URLOPEN, side_effect=[urllib.error.URLError("down"), _health(200)]), \
-                patch(_GATEWAY), patch(_RUN, side_effect=fake), patch(_SLEEP):
-            self.assertEqual(self.svc.url, self.svc.ensure_running())
-        runs = [c for c in calls if c[: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)
@@ -130,42 +97,6 @@ class TestRegistryStore(unittest.TestCase):
         self.assertNotIn("identity_token", rec.redacted())
         self.assertEqual("10.243.0.1", rec.redacted()["source_ip"])
 
-    def test_register_with_policy_resolves_via_attribution(self) -> None:
-        rec = self.store.register("10.243.0.1", policy='{"allow":["x"]}')
-        self.assertEqual('{"allow":["x"]}', rec.policy)
-        got = self.store.attribute("10.243.0.1", rec.identity_token)
-        assert got is not None
-        self.assertEqual('{"allow":["x"]}', got.policy)
-
-    def test_set_policy_updates_live(self) -> None:
-        rec = self.store.register("10.243.0.1")
-        self.assertEqual("", rec.policy)
-        self.assertTrue(self.store.set_policy(rec.bottle_id, '{"v":2}'))
-        got = self.store.get(rec.bottle_id)
-        assert got is not None
-        self.assertEqual('{"v":2}', got.policy)
-
-    def test_set_policy_missing_is_false(self) -> None:
-        self.assertFalse(self.store.set_policy("ghost", "{}"))
-
-    def test_policy_defaults_empty_and_persists(self) -> None:
-        rec = self.store.register("10.243.0.1")
-        got = RegistryStore(self.db).get(rec.bottle_id)
-        assert got is not None
-        self.assertEqual("", got.policy)
-
-    def test_by_source_ip_returns_single_active(self) -> None:
-        rec = self.store.register("10.243.0.1")
-        got = self.store.by_source_ip("10.243.0.1")
-        assert got is not None
-        self.assertEqual(rec.bottle_id, got.bottle_id)
-
-    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.assertIsNone(self.store.by_source_ip("10.243.0.1"))  # ambiguous
-
 
 if __name__ == "__main__":
     unittest.main()

tests/unit/test_orchestrator_service.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from bot_bottle.orchestrator.broker import LaunchBroker, LaunchRequest, StubBroker
 from bot_bottle.orchestrator.registry import RegistryStore
 from bot_bottle.orchestrator.service import Orchestrator
-from bot_bottle.orchestrator.gateway import Gateway
+from bot_bottle.orchestrator.sidecar import Sidecar
 
 
 class _FailingBroker(LaunchBroker):
@@ -24,11 +24,11 @@ class _FailingBroker(LaunchBroker):
         pass
 
 
-class _FakeGateway(Gateway):
-    """In-memory gateway for wiring tests."""
+class _FakeSidecar(Sidecar):
+    """In-memory sidecar for wiring tests."""
 
     def __init__(self) -> None:
-        self.name = "fake-gateway"
+        self.name = "fake-sidecar"
         self.ensured = 0
         self.built = 0
         self._running = False
@@ -86,69 +86,29 @@ class TestOrchestrator(unittest.TestCase):
     def test_teardown_unknown_is_false(self) -> None:
         self.assertFalse(self.orch.teardown_bottle("ghost"))
 
-    def test_launch_with_policy_is_resolvable(self) -> None:
-        rec = self.orch.launch_bottle("10.243.0.1", policy='{"routes":[]}')
-        got = self.orch.attribute("10.243.0.1", rec.identity_token)
-        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}'))
-        got = self.orch.attribute("10.243.0.3", rec.identity_token)
-        assert got is not None
-        self.assertEqual('{"x":1}', got.policy)
-
-    def test_set_policy_unknown_is_false(self) -> None:
-        self.assertFalse(self.orch.set_policy("ghost", "{}"))
-
-    def test_resolve_by_source_ip_without_token(self) -> None:
-        rec = self.orch.launch_bottle("10.243.0.1", policy="P")
-        got = self.orch.resolve("10.243.0.1")  # network-layer, no token
-        assert got is not None
-        self.assertEqual(rec.bottle_id, got.bottle_id)
-        self.assertEqual("P", got.policy)
-
-    def test_resolve_with_token_stays_strict(self) -> None:
-        rec = self.orch.launch_bottle("10.243.0.3")
-        self.assertIsNotNone(self.orch.resolve("10.243.0.3", rec.identity_token))
-        self.assertIsNone(self.orch.resolve("10.243.0.3", "wrong-token"))
-
     def test_launch_rolls_back_registry_on_broker_failure(self) -> None:
         orch = Orchestrator(self.store, _FailingBroker(self.secret), self.secret)
         with self.assertRaises(RuntimeError):
             orch.launch_bottle("10.243.0.9")
         self.assertEqual([], self.store.all())  # no orphan
 
-    def test_gateway_unconfigured_by_default(self) -> None:
-        self.assertEqual({"configured": False}, self.orch.gateway_status())
-        self.orch.ensure_gateway()  # no-op, must not raise
+    def test_sidecar_unconfigured_by_default(self) -> None:
+        self.assertEqual({"configured": False}, self.orch.sidecar_status())
+        self.orch.ensure_sidecar()  # no-op, must not raise
 
-    def test_gateway_wired_and_ensured(self) -> None:
-        sc = _FakeGateway()
-        orch = Orchestrator(self.store, self.broker, self.secret, gateway=sc)
+    def test_sidecar_wired_and_ensured(self) -> None:
+        sc = _FakeSidecar()
+        orch = Orchestrator(self.store, self.broker, self.secret, sidecar=sc)
         self.assertEqual(
-            {"configured": True, "name": "fake-gateway", "running": False},
-            orch.gateway_status(),
+            {"configured": True, "name": "fake-sidecar", "running": False},
+            orch.sidecar_status(),
         )
-        orch.ensure_gateway()
-        self.assertEqual(1, sc.built)   # ensure_gateway builds first,
+        orch.ensure_sidecar()
+        self.assertEqual(1, sc.built)   # ensure_sidecar builds first,
         self.assertEqual(1, sc.ensured)  # then runs
         self.assertEqual(
-            {"configured": True, "name": "fake-gateway", "running": True},
-            orch.gateway_status(),
+            {"configured": True, "name": "fake-sidecar", "running": True},
+            orch.sidecar_status(),
         )
 
 

tests/unit/test_orchestrator_sidecar.py

@@ -0,0 +1,129 @@
+"""Unit tests for the consolidated Docker sidecar (PRD 0070). Docker mocked."""
+
+from __future__ import annotations
+
+import unittest
+from unittest.mock import Mock, patch
+
+from bot_bottle.orchestrator.sidecar import (
+    SIDECAR_NAME,
+    DockerSidecar,
+    SidecarError,
+)
+
+_RUN_DOCKER = "bot_bottle.orchestrator.sidecar.run_docker"
+
+
+def _proc(returncode: int = 0, stdout: str = "", stderr: str = "") -> Mock:
+    return Mock(returncode=returncode, stdout=stdout, stderr=stderr)
+
+
+class TestDockerSidecar(unittest.TestCase):
+    def setUp(self) -> None:
+        self.sc = DockerSidecar("bot-bottle-sidecars:latest")
+
+    def test_default_name(self) -> None:
+        self.assertEqual(SIDECAR_NAME, self.sc.name)
+
+    def test_is_running_reads_docker_ps(self) -> None:
+        with patch(_RUN_DOCKER, return_value=_proc(stdout=self.sc.name + "\n")):
+            self.assertTrue(self.sc.is_running())
+        with patch(_RUN_DOCKER, return_value=_proc(stdout="")):
+            self.assertFalse(self.sc.is_running())
+
+    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()
+        # 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]] = []
+
+        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()
+
+        runs = [c for c in calls if c[:2] == ["docker", "run"]]
+        self.assertEqual(1, len(runs))
+        self.assertIn(self.sc.name, runs[0])
+        self.assertIn("bot-bottle-sidecars:latest", runs[0])
+
+    def test_ensure_running_raises_on_docker_failure(self) -> None:
+        def fake(argv: list[str]) -> Mock:
+            if argv[:2] == ["docker", "ps"]:
+                return _proc(stdout="")
+            if argv[:2] == ["docker", "run"]:
+                return _proc(returncode=1, stderr="boom")
+            return _proc()
+
+        with patch(_RUN_DOCKER, side_effect=fake):
+            with self.assertRaises(SidecarError):
+                self.sc.ensure_running()
+
+    def test_stop_is_idempotent_on_missing(self) -> None:
+        absent = _proc(returncode=1, stderr="Error: No such container: x")
+        with patch(_RUN_DOCKER, return_value=absent):
+            self.sc.stop()  # must not raise
+
+    def test_stop_raises_on_other_failure(self) -> None:
+        with patch(_RUN_DOCKER, return_value=_proc(returncode=1, stderr="daemon down")):
+            with self.assertRaises(SidecarError):
+                self.sc.stop()
+
+
+class TestDockerSidecarBuild(unittest.TestCase):
+    def setUp(self) -> None:
+        self.sc = DockerSidecar()  # defaults to the real bundle image + dockerfile
+
+    def test_image_exists_reads_docker_inspect(self) -> None:
+        with patch(_RUN_DOCKER, return_value=_proc(returncode=0)):
+            self.assertTrue(self.sc.image_exists())
+        with patch(_RUN_DOCKER, return_value=_proc(returncode=1)):
+            self.assertFalse(self.sc.image_exists())
+
+    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 fake(argv: list[str]) -> Mock:
+            calls.append(argv)
+            if argv[:3] == ["docker", "image", "inspect"]:
+                return _proc(returncode=1)  # missing
+            return _proc()
+
+        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]))
+
+    def test_ensure_built_noop_when_no_dockerfile(self) -> None:
+        sc = DockerSidecar("busybox", dockerfile=None)
+        with patch(_RUN_DOCKER) as m:
+            sc.ensure_built()
+        m.assert_not_called()
+
+    def test_ensure_built_raises_on_build_failure(self) -> None:
+        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(SidecarError):
+                self.sc.ensure_built()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/unit/test_policy_resolver.py

@@ -1,111 +0,0 @@
-"""Unit tests for the gateway-side PolicyResolver (PRD 0070). HTTP mocked."""
-
-from __future__ import annotations
-
-import json
-import unittest
-import urllib.error
-from unittest.mock import MagicMock, patch
-
-from bot_bottle.policy_resolver import PolicyResolveError, PolicyResolver
-
-_URLOPEN = "bot_bottle.policy_resolver.urllib.request.urlopen"
-
-
-def _resp(payload: object) -> MagicMock:
-    """A urlopen() return value: a context manager whose read() yields JSON."""
-    m = MagicMock()
-    m.__enter__.return_value.read.return_value = json.dumps(payload).encode()
-    return m
-
-
-def _http_error(code: int) -> urllib.error.HTTPError:
-    return urllib.error.HTTPError("http://x/resolve", code, "err", {}, None)  # type: ignore[arg-type]
-
-
-class TestPolicyResolver(unittest.TestCase):
-    def setUp(self) -> None:
-        self.r = PolicyResolver("http://orch:8080")
-
-    def test_resolve_returns_policy(self) -> None:
-        with patch(_URLOPEN, return_value=_resp({"bottle_id": "b1", "policy": "P"})):
-            self.assertEqual("P", self.r.resolve("10.243.0.1", "tok"))
-
-    def test_resolve_always_fetches_fresh(self) -> None:
-        # No cache — every resolve hits the orchestrator so revocations /
-        # policy changes are honored immediately.
-        with patch(_URLOPEN, return_value=_resp({"policy": "P"})) as m:
-            self.r.resolve("10.243.0.1", "tok")
-            self.r.resolve("10.243.0.1", "tok")
-        self.assertEqual(2, m.call_count)
-
-    def test_unattributed_403_is_none_fail_closed(self) -> None:
-        with patch(_URLOPEN, side_effect=_http_error(403)):
-            self.assertIsNone(self.r.resolve("10.243.0.9", "tok"))
-
-    def test_other_http_error_raises(self) -> None:
-        with patch(_URLOPEN, side_effect=_http_error(500)):
-            with self.assertRaises(PolicyResolveError):
-                self.r.resolve("10.243.0.1", "tok")
-
-    def test_unreachable_raises(self) -> None:
-        with patch(_URLOPEN, side_effect=urllib.error.URLError("refused")):
-            with self.assertRaises(PolicyResolveError):
-                self.r.resolve("10.243.0.1", "tok")
-
-    def test_missing_policy_field_is_empty(self) -> None:
-        with patch(_URLOPEN, return_value=_resp({"bottle_id": "b1"})):
-            self.assertEqual("", self.r.resolve("10.243.0.1", "tok"))
-
-    def test_posts_source_ip_and_token(self) -> None:
-        with patch(_URLOPEN, return_value=_resp({"policy": "P"})) as m:
-            self.r.resolve("10.243.0.7", "the-token")
-        req = m.call_args.args[0]
-        self.assertTrue(req.full_url.endswith("/resolve"))
-        sent = json.loads(req.data)
-        self.assertEqual("10.243.0.7", sent["source_ip"])
-        self.assertEqual("the-token", sent["identity_token"])
-
-    def test_resolve_without_token_sends_empty(self) -> None:
-        with patch(_URLOPEN, return_value=_resp({"policy": "P"})) as m:
-            self.r.resolve("10.243.0.7")  # token optional
-        self.assertEqual("", json.loads(m.call_args.args[0].data)["identity_token"])
-
-    def test_resolve_bottle_id_returns_id(self) -> None:
-        with patch(_URLOPEN, return_value=_resp({"bottle_id": "b1", "policy": "P"})):
-            self.assertEqual("b1", self.r.resolve_bottle_id("10.243.0.1", "tok"))
-
-    def test_resolve_bottle_id_403_is_none_fail_closed(self) -> None:
-        with patch(_URLOPEN, side_effect=_http_error(403)):
-            self.assertIsNone(self.r.resolve_bottle_id("10.243.0.9", "tok"))
-
-    def test_resolve_bottle_id_missing_field_is_none(self) -> None:
-        with patch(_URLOPEN, return_value=_resp({"policy": "P"})):
-            self.assertIsNone(self.r.resolve_bottle_id("10.243.0.1", "tok"))
-
-    def test_resolve_bottle_id_error_raises(self) -> None:
-        with patch(_URLOPEN, side_effect=_http_error(500)):
-            with self.assertRaises(PolicyResolveError):
-                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
-
-    def test_resolve_policy_and_bottle_id_403_is_none_none_empty(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"))
-
-    def test_resolve_policy_and_bottle_id_error_raises(self) -> None:
-        with patch(_URLOPEN, side_effect=urllib.error.URLError("refused")):
-            with self.assertRaises(PolicyResolveError):
-                self.r.resolve_policy_and_bottle_id("10.243.0.1")
-
-
-if __name__ == "__main__":
-    unittest.main()

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