feat(orchestrator+egress): slice 8 — multi-tenant egress via the resolver (#352)

The egress addon now selects each request's Config by the calling bottle's
source IP, so one shared sidecar serves every bottle. Opt-in and fail-closed;
single-tenant behaviour is unchanged.

Orchestrator side (source-IP-primary attribution, per the PRD invariant):
  * registry: `by_source_ip` (the single active bottle at a source IP —
    network-layer attribution); `attribute` now composes it + the token.
  * service: `resolve(source_ip, token="")` — with a token, strict
    attribution; without, source IP alone.
  * control_plane: `POST /resolve`'s identity_token is now OPTIONAL (absent
    → source-IP-only); split cleanly from the token-required `/attribute`.
  * policy_resolver: `resolve` token now optional.

Egress side:
  * egress_addon_core: `resolve_client_config(resolver, client_ip, token)` —
    fetches + parses the client's Config, **fail-closed**: unattributed, a
    resolver error, or an unparseable policy all yield deny-all (no routes).
    Host-testable; `PolicyResolverLike` Protocol keeps it import-free.
  * egress_addon: consolidated mode when `BOT_BOTTLE_ORCHESTRATOR_URL` is
    set → `_active_config(flow)` resolves per client IP (reads + strips the
    `x-bot-bottle-identity` header); `request()` uses it. Unset → the static
    routes file, exactly as before. `PolicyResolver` added to the bundle.

Security note: source-IP-only resolution is safe where the IP is unspoofable
(Firecracker /31 + nft) AND the control plane is reachable only by the
trusted sidecar; the identity token, when the agent injects it, strengthens
it on weaker backends.

Scope note: the egress data plane is now multi-tenant. Remaining to be fully
live: the network topology routing every bottle's proxy to the one shared
sidecar, git-gate multitenancy, and agent-side identity-token injection.

Tests: registry by_source_ip; orchestrator resolve (with/without token);
control-plane /resolve token-optional; resolver token-optional;
resolve_client_config fail-closed matrix. All 182 egress tests still pass
(single-tenant unchanged). Full suite green.

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

AGENTS.md

@@ -8,10 +8,10 @@ broad permissions inside a sandbox, so a misbehaving agent cannot reach the
 host. A Python CLI (entry point `cli.py`, package `bot_bottle/`) orchestrates
 the runtime lifecycle and the copying of skills and env vars into it.
 The default backend on compatible macOS hosts is macos-container:
-agents and gateways run through Apple's `container` CLI without
+agents and sidecar bundles run through Apple's `container` CLI without
 requiring Docker. On KVM-capable Linux hosts the default is firecracker:
 agents run in a Firecracker microVM reached over SSH on a point-to-point
-TAP, while the gateway still uses Docker. The legacy Docker
+TAP, while the sidecar bundle still uses Docker. The legacy Docker
 backend remains available with `BOT_BOTTLE_BACKEND=docker` or
 `--backend=docker`.
 
@@ -59,7 +59,7 @@ backend remains available with `BOT_BOTTLE_BACKEND=docker` or
   in a PRD, research note, or decision record.
 - Low dependencies by default. The project is Python, stdlib-first (no
   runtime pip dependencies in the package itself; the only language
-  runtime is the Python 3.13 used by the CLI + companion containers). Ask before
+  runtime is the Python 3.13 used by the CLI + sidecars). Ask before
   adding new tools, runtimes, or package managers.
 - Commit messages follow [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/):
   `<type>[(scope)][!]: <description>`, where `<type>` is one of `feat`, `fix`,

Dockerfile.infra

@@ -1,45 +0,0 @@
-# Firecracker single infra-VM image (PRD 0070 Stage B).
-#
-# The per-host infra VM runs the orchestrator control plane, the gateway
-# data plane, AND builds agent images (buildah) — all in one microVM (see
-# backend/firecracker/infra_vm.py). It composes:
-#   * FROM the gateway image (mitmproxy / git / gitleaks / supervise + the
-#     flat daemon modules) — now trixie-based, so buildah 1.39 is available;
-#   * `COPY --from` the orchestrator image's content (the single definition
-#     of the control-plane payload — see Dockerfile.orchestrator), so this
-#     VM and the docker backend share one orchestrator definition; and
-#   * buildah, installed HERE only (the docker orchestrator/gateway images
-#     never carry it).
-#
-# multi-`FROM` can't union two bases (that's multi-stage, not multiple
-# inheritance), so the orchestrator content is pulled in via `COPY --from`
-# rather than a second base. Both images share the trixie `python:3.12-slim`
-# base, so the copy is clean (same python; future installed deps copy too).
-#
-# The docker backend keeps orchestrator + gateway as separate images; this
-# combined image exists only for the Firecracker single-VM cut. Splitting a
-# service back into its own VM later is a routing change, not a repackaging
-# (PRD 0070's "secret concentration"; a disposable builder can boot from
-# this same image on its own TAP).
-FROM bot-bottle-gateway:latest
-
-# --- in-VM agent-image builder (PRD 0069 Stage 3) -------------------
-# The Firecracker backend builds users' agent Dockerfiles *inside this VM*
-# with buildah (rootless, daemonless) instead of on the host — no host
-# Docker daemon, no root-equivalent `docker` group. `crun` is the OCI
-# runtime; `netavark` + `aardvark-dns` are the network backend for `FROM`
-# pulls + `RUN` egress. Requires the trixie base (buildah 1.39: bookworm's
-# 1.28 can't parse Dockerfile heredocs that agent images use).
-RUN apt-get update \
- && apt-get install -y --no-install-recommends \
-      buildah crun netavark aardvark-dns \
- && rm -rf /var/lib/apt/lists/*
-# vfs + chroot: buildah works as root in the bare microVM (no
-# fuse-overlayfs / overlay module / subuid maps). Matches image_builder.
-ENV STORAGE_DRIVER=vfs \
-    BUILDAH_ISOLATION=chroot
-
-# The orchestrator content, pulled from its single definition. The gateway
-# image already has the flat daemon modules under /app; this adds the full
-# `bot_bottle` package so `python3 -m bot_bottle.orchestrator` resolves.
-COPY --from=bot-bottle-orchestrator:latest /app/bot_bottle /app/bot_bottle

Dockerfile.orchestrator

@@ -1,36 +0,0 @@
-# Orchestrator control-plane image (PRD 0070, #384).
-#
-# This is the **single definition of the orchestrator's content** — the
-# `bot_bottle` package baked onto a Python runtime — referenced by BOTH:
-#   * the docker backend, which runs this image directly as the lean
-#     control-plane container; and
-#   * the firecracker infra image (Dockerfile.infra), which `COPY --from`s
-#     this image's `/app/bot_bottle` so the single infra VM runs the same
-#     control plane. Keeping it in one place means future orchestrator deps
-#     (e.g. iroh) are added here once, not duplicated per backend.
-#
-# It stays deliberately lean: the control plane is **stdlib-only** today, so
-# no third-party payload — none of the gateway's mitmproxy/git/gitleaks
-# (that's Dockerfile.gateway) and no buildah (that's the firecracker
-# builder, and lives only in Dockerfile.infra). Keeping the secret-dense
-# control plane on a minimal dependency surface is the point (PRD 0070's
-# "secret concentration").
-#
-# Shares the trixie `python:3.12-slim` base with the gateway image, so when
-# the orchestrator grows real deps they can be `COPY --from`'d into the
-# infra image cleanly (same base/python — installed packages copy safely).
-
-FROM python:3.12-slim
-
-WORKDIR /app
-
-# The orchestrator content. Baked so the image is self-contained (runs from
-# a built image, no runtime bind-mount); the docker backend may still
-# bind-mount /app for dev live-reload, which simply overlays this copy.
-# `.dockerignore` keeps .git/docs/*.md out of the context. (Future deps like
-# iroh go here too — a shared requirements installed on this same base.)
-COPY bot_bottle /app/bot_bottle
-
-# Documentation only; lifecycle.py overrides the entrypoint to
-# `python3 -m bot_bottle.orchestrator` with the runtime flags.
-ENTRYPOINT ["python3", "-m", "bot_bottle.orchestrator"]

Dockerfile.sidecars

@@ -1,15 +1,8 @@
-# Gateway data-plane image (PRD 0024 bundle shape; PRD 0070 gateway).
+# Per-bottle sidecar bundle image (PRD 0024).
 #
-# The egress / git-gate / supervise *data plane* — one image, run by
+# Collapses the prior per-sidecar images (egress, git-gate,
-# the consolidated per-host gateway (PRD 0070). It is NOT the
-# orchestrator control plane: that is the separate, lean
-# `bot-bottle-orchestrator` image (Dockerfile.orchestrator, #384), which
-# ships only python + the stdlib-only `bot_bottle` package and none of
-# this image's mitmproxy / git / gitleaks payload.
-#
-# Collapses the prior per-daemon images (egress, git-gate,
 # supervise) into one. A small stdlib-Python init supervisor at
-# /app/gateway_init.py spawns all daemons, forwards SIGTERM, and
+# /app/sidecar_init.py spawns all daemons, forwards SIGTERM, and
 # propagates per-daemon stdout/stderr to the container log with a
 # `[name]` prefix. See PRD 0024 for the rationale.
 #
@@ -19,7 +12,7 @@
 #   /app/egress_addon.py + siblings      mitmproxy addon (egress)
 #   /app/egress-entrypoint.sh            mitmdump launcher
 #   /app/supervise_server.py + .py       supervise MCP server
-#   /app/gateway_init.py                 PID 1 supervisor
+#   /app/sidecar_init.py                 PID 1 supervisor
 #   /etc/egress/routes.yaml              bind-mounted at run time
 #   /etc/git-gate/pre-receive            docker-cp'd at start time
 #   /git-gate-entrypoint.sh              docker-cp'd at start time
@@ -34,45 +27,35 @@
 #   9420  git-gate smart HTTP (VM-backend agent-facing transport)
 #   9100  supervise (MCP HTTP)
 
-# Based on `python:3.12-slim` (Debian trixie) rather than the
+# Stage 1: gitleaks binary. The upstream gitleaks image is alpine
-# `mitmproxy/mitmproxy` image (Debian bookworm) so the whole stack —
+# with the binary at /usr/bin/gitleaks. Pinned by digest in lockstep
-# gateway here, and the firecracker infra image that builds FROM this —
+# with Dockerfile.git-gate's prior base (now deleted at chunk 3).
-# lands on trixie, whose buildah (1.39) can build agent Dockerfiles that
+FROM zricethezav/gitleaks@sha256:c00b6bd0aeb3071cbcb79009cb16a60dd9e0a7c60e2be9ab65d25e6bc8abbb7f AS gitleaks-src
-# use heredocs. mitmproxy is pip-installed to the same effect as the
+
-# upstream image. (bookworm's buildah is 1.28, which can't parse
+# Stage 2: assembly. mitmproxy/mitmproxy is debian-slim-based with
-# `RUN ... <<EOF`; see the infra image + PR discussion.)
+# Python + mitmdump pre-installed — heavier than the others, so
-FROM python:3.12-slim
+# this stage starts there and pulls the standalone binaries in.
+FROM mitmproxy/mitmproxy:11.1.3
+
+# Run as root inside the bundle. The bundle is the isolation
+# boundary; per-daemon user separation inside it is not load-bearing
+# and complicates the supervisor's spawn path.
+USER root
 
 # Runtime system deps:
 #   git supplies the `git daemon` subcommand (no separate package)
 #     plus the core `git` binary the pre-receive hook invokes.
 #   openssh-client supplies the upstream SSH transport the
 #     pre-receive hook uses to forward accepted refs.
-#   ca-certificates is needed for mitmdump upstream TLS.
+#   ca-certificates is needed for mitmdump upstream TLS (the
+#     base image already has it; listed for explicitness).
 RUN apt-get update \
  && apt-get install -y --no-install-recommends \
       git openssh-client ca-certificates \
  && rm -rf /var/lib/apt/lists/*
 
-# mitmdump (the egress data plane). The upstream mitmproxy image baked
+# Pull the standalone binaries into the final image.
-# this in; on the plain python base we pip-install the same pinned
+COPY --from=gitleaks-src /usr/bin/gitleaks /usr/bin/gitleaks
-# version. Its CA dir is set explicitly via `--set confdir=` in
-# egress-entrypoint.sh, so it doesn't depend on a `mitmproxy` home user.
-RUN pip install --no-cache-dir mitmproxy==11.1.3
-
-# gitleaks (the pre-receive hook's secret scanner). Installed from its
-# official release, pinned by version + SHA256 and verified — rather than
-# using a third-party image as a build stage (supply-chain surface, and it
-# would pin us to that image's cadence). python (already present) does the
-# download so we add no curl/wget. trixie apt also ships gitleaks, but an
-# older 8.16; the pinned download keeps the verified 8.30.1.
-ARG GITLEAKS_VERSION=8.30.1
-ARG GITLEAKS_SHA256=551f6fc83ea457d62a0d98237cbad105af8d557003051f41f3e7ca7b3f2470eb
-RUN url="https://github.com/gitleaks/gitleaks/releases/download/v${GITLEAKS_VERSION}/gitleaks_${GITLEAKS_VERSION}_linux_x64.tar.gz" \
- && python3 -c "import sys,urllib.request; urllib.request.urlretrieve(sys.argv[1], '/tmp/gitleaks.tar.gz')" "$url" \
- && echo "${GITLEAKS_SHA256}  /tmp/gitleaks.tar.gz" | sha256sum -c - \
- && tar -xzf /tmp/gitleaks.tar.gz -C /usr/bin gitleaks \
- && rm /tmp/gitleaks.tar.gz
 
 # Project Python: addon + server modules + the init supervisor.
 # Kept flat under /app/ so mitmdump's loader resolves them as
@@ -93,7 +76,7 @@ COPY bot_bottle/audit_store.py       /app/audit_store.py
 COPY bot_bottle/store_manager.py     /app/store_manager.py
 COPY bot_bottle/supervise.py         /app/supervise.py
 COPY bot_bottle/supervise_server.py  /app/supervise_server.py
-COPY bot_bottle/gateway_init.py      /app/gateway_init.py
+COPY bot_bottle/sidecar_init.py      /app/sidecar_init.py
 COPY bot_bottle/git_http_backend.py  /app/git_http_backend.py
 COPY bot_bottle/egress_entrypoint.sh /app/egress-entrypoint.sh
 RUN chmod +x /app/egress-entrypoint.sh
@@ -119,4 +102,4 @@ WORKDIR /app
 
 # PID 1 is the supervisor. It owns signal handling and exit-code
 # propagation; no `exec` chain in the entrypoint itself.
-ENTRYPOINT ["python3", "/app/gateway_init.py"]
+ENTRYPOINT ["python3", "/app/sidecar_init.py"]

README.md

@@ -16,7 +16,7 @@
 
 - **Per-bottle egress allowlist** — TLS-bumped HTTP/HTTPS chokepoint with a per-manifest host allowlist; per-route path/method/header `matches` filtering; outbound DLP scanning for known tokens and secrets, inbound DLP scanning for prompt-injection attempts; DoH and arbitrary hosts blocked by default.
 - **Per-route token-match policy** — each egress route picks what happens when the outbound DLP catches a token via `dlp.outbound_on_match`: `supervise` (default) holds the request and surfaces it in `./cli.py supervise` for approval (an approved value is remembered for the life of the proxy); `redact` scrubs the value and forwards; `block` is a hard `403`. Cuts false-positive friction without weakening default-deny.
-- **Tokens the agent never sees** — host secrets live in a gateway; the agent dials `http://gateway:9099/<path>` and the proxy strips inbound `Authorization` and injects the real token before forwarding. `printenv` in the agent shows proxy URLs only.
+- **Tokens the agent never sees** — host secrets live in a sidecar; the agent dials `http://sidecar:9099/<path>` and the proxy strips inbound `Authorization` and injects the real token before forwarding. `printenv` in the agent shows proxy URLs only.
 - **Gitleaks-scanned push (git-gate)** — `bottle.git` remotes route through a per-bottle `git daemon` that gitleaks-scans incoming refs pre-receive and forwards clean refs upstream over SSH. The agent never holds the upstream credential.
 - **Manifest-scoped skills + secrets** — each bottle declares its skills, env, git identity, remotes, and egress routes; unknown keys die at load.
 - **Trust boundary at `$HOME`** — bottles (credentials, egress, remotes) live only under `~/.bot-bottle/bottles/`. Repos may ship agents but not bottles, so a cloned repo can't redirect an env var to an attacker host.
@@ -24,17 +24,17 @@
 - **Parallel, isolated bottles** — each bottle runs in its own backend-owned isolation boundary; bottles don't share state or talk to each other.
 - **Provider templates (Claude, Codex)** — `Dockerfile.claude` / `Dockerfile.codex`, or a bottle-supplied Dockerfile. Claude auth via long-lived OAuth token; Codex via opt-in host device-auth forwarding.
 - **gVisor auto-detect** — on Linux hosts where `runsc` is registered with Docker, every bottle launches under it for a userspace syscall barrier; no manifest config required.
-- **Apple Container backend (macOS default when available)** — runs the agent and gateway with Apple's `container` CLI, using a host-only agent network plus a separate gateway egress network.
+- **Apple Container backend (macOS default when available)** — runs the agent and sidecar bundle with Apple's `container` CLI, using a host-only agent network plus a separate sidecar egress network.
-- **Firecracker backend (Linux default when available)** — runs the agent in a KVM Firecracker microVM reached over SSH on a point-to-point TAP, with the gateway in Docker. A dedicated, fail-closed `nftables` table isolates the guest, closing the raw DNS/IP exfiltration gap that exists in the legacy Docker backend. Requires KVM (`/dev/kvm`) and a one-time privileged network-pool setup.
+- **Firecracker backend (Linux default when available)** — runs the agent in a KVM Firecracker microVM reached over SSH on a point-to-point TAP, with the sidecar bundle in Docker. A dedicated, fail-closed `nftables` table isolates the guest, closing the raw DNS/IP exfiltration gap that exists in the legacy Docker backend. Requires KVM (`/dev/kvm`) and a one-time privileged network-pool setup.
 - **Legacy Docker backend** — still available for examples, CI, and hosts without Apple Container or KVM via `BOT_BOTTLE_BACKEND=docker` or `--backend=docker`.
 
 ## Architecture
 
-On the default macOS Apple Container backend, a bottle is an agent container on a host-only internal network plus a gateway attached to both that internal network and a NAT egress network. The agent gets HTTP(S)_PROXY and CA bundle env vars pointing at the gateway's internal-network IP, so HTTP/HTTPS traffic flows through the gateway instead of direct egress. `bottle.git` / git-gate is intentionally deferred on this backend until a safe Apple Container key-delivery path exists.
+On the default macOS Apple Container backend, a bottle is an agent container on a host-only internal network plus a sidecar bundle attached to both that internal network and a NAT egress network. The agent gets HTTP(S)_PROXY and CA bundle env vars pointing at the sidecar's internal-network IP, so HTTP/HTTPS traffic flows through the sidecar instead of direct egress. `bottle.git` / git-gate is intentionally deferred on this backend until a safe Apple Container key-delivery path exists.
 
-On the Firecracker backend, a bottle is an agent microVM plus a Docker gateway for egress, git-gate, and supervise. The VM reaches the gateway over a per-bottle point-to-point TAP link; a dedicated fail-closed `nftables` table (`inet bot_bottle_fc`) confines the guest to that link, so nothing leaves the box except through the gateway. The TAP pool and nft table are provisioned once (root); per-launch needs no privilege.
+On the Firecracker backend, a bottle is an agent microVM plus a Docker sidecar bundle for egress, git-gate, and supervise. The VM reaches the sidecars over a per-bottle point-to-point TAP link; a dedicated fail-closed `nftables` table (`inet bot_bottle_fc`) confines the guest to that link, so nothing leaves the box except through the sidecars. The TAP pool and nft table are provisioned once (root); per-launch needs no privilege.
 
-On the legacy Docker backend, the same logical bottle is two containers per agent: an `agent` container and a `companion containers` container. They share a per-agent Docker `--internal` network; the agent has no default route off-box.
+On the legacy Docker backend, the same logical bottle is two containers per agent: an `agent` container and a `sidecars` container. They share a per-agent Docker `--internal` network; the agent has no default route off-box.
 
 The Docker topology looks like this:
 
@@ -67,11 +67,11 @@ The Docker topology looks like this:
    └─────────────────────────────────────────────────────────────────────┘
 ```
 
-When the agent exits, `cli.py` tears down every gateway and both networks; nothing about a bottle persists between runs.
+When the agent exits, `cli.py` tears down every sidecar and both networks; nothing about a bottle persists between runs.
 
 ## Quickstart
 
-On compatible macOS hosts, the default backend requires Apple's `container` CLI and does not require Docker. The Firecracker backend (Linux) requires Docker on the host for the gateway plus the `firecracker` binary and KVM. The legacy Docker backend requires Docker. Claude bottles also need a long-lived Claude Code OAuth token (`claude setup-token`) exported as `BOT_BOTTLE_CLAUDE_OAUTH_TOKEN`.
+On compatible macOS hosts, the default backend requires Apple's `container` CLI and does not require Docker. The Firecracker backend (Linux) requires Docker on the host for the sidecar bundle plus the `firecracker` binary and KVM. The legacy Docker backend requires Docker. Claude bottles also need a long-lived Claude Code OAuth token (`claude setup-token`) exported as `BOT_BOTTLE_CLAUDE_OAUTH_TOKEN`.
 
 Use `BOT_BOTTLE_BACKEND=docker ./cli.py start <agent>` on hosts where neither Apple Container nor KVM is available and Docker is the desired backend.
 
@@ -81,7 +81,7 @@ On Linux, a KVM-capable host defaults to the Firecracker backend. It needs:
 
 - **`/dev/kvm`** present and accessible. Load `kvm-intel` or `kvm-amd` (and enable virtualization in BIOS/firmware). The invoking user must be in the `kvm` group: `sudo usermod -aG kvm "$USER"` then re-login. bot-bottle preflights this and reports exactly what's missing.
 - **`firecracker`** on `PATH`: grab a release from <https://github.com/firecracker-microvm/firecracker/releases>. Start flows print this pointer when the binary is missing.
-- **Docker** for the gateway and image build.
+- **Docker** for the sidecar bundle and image build.
 - **A one-time privileged network setup** — the per-bottle TAP pool plus the fail-closed `nftables` isolation table. Run `./cli.py backend setup --backend=firecracker` for the host-appropriate config (a NixOS module, a `sudo` script elsewhere); `./cli.py backend status --backend=firecracker` reports what's present, including whether the pool range collides with an existing route. The pool defaults to `10.243.0.0/16` (an obscure RFC-1918 block that dodges docker/libvirt/LAN and, deliberately, Tailscale's `100.64.0.0/10` CGNAT range); override with `BOT_BOTTLE_FC_IP_BASE` if it clashes on your host.
 
 ```sh

bot_bottle/agent_provider.py

@@ -61,13 +61,6 @@ class AgentProviderRuntime:
     prompt_mode: PromptMode
     bypass_args: tuple[str, ...]
     resume_args: tuple[str, ...]
-    # argv run inside a throwaway container of a freshly built agent
-    # image, right after `build_image()`, to catch a build that
-    # exited 0 but produced a broken CLI (e.g. an npm
-    # optionalDependencies fetch for a platform-native binary that
-    # silently no-ops on a transient failure). Empty tuple skips the
-    # check — not every provider has opted in yet.
-    smoke_test: tuple[str, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -211,9 +204,9 @@ class AgentProvider(ABC):
         bottle: "Bottle",
         supervise_url: str,
     ) -> None:
-        """Register the per-bottle supervise daemon as an MCP server
+        """Register the per-bottle supervise sidecar as an MCP server
         in the provider's in-guest config. Called by the backend after
-        the supervise daemon is reachable. No-op when
+        the supervise sidecar is reachable. No-op when
         `plan.supervise_plan is None`."""
 
     @abstractmethod
@@ -266,7 +259,6 @@ class AgentProvider(ABC):
             gate_scheme = getattr(plan, "git_gate_insteadof_scheme", "git")
             content = git_gate_render_gitconfig(
                 manifest_bottle.git, gate_host, scheme=gate_scheme,
-                identity_token=getattr(plan, "identity_token", ""),
             )
             guest_gitconfig = f"{plan.guest_home}/.gitconfig"
             with tempfile.NamedTemporaryFile(

bot_bottle/backend/__init__.py

@@ -199,7 +199,7 @@ class ActiveAgent:
     bottle is the container, the agent is what runs in it.)
 
     Fields are deliberately backend-neutral. `services` is the set
-    of gateway daemons currently up for this bottle (`egress`,
+    of sidecar daemons currently up for this bottle (`egress`,
     `git-gate`, `supervise`); the dashboard uses it to
     gate edit verbs. `backend_name` is the matching key in
     `_BACKENDS` (`docker` / `firecracker` / `macos-container`) — used by the active-
@@ -251,7 +251,7 @@ class Bottle(ABC):
         `user` (default `node`, matching the agent image's USER
         directive) and return the captured stdout/stderr/returncode.
         The bottle's environment (including HTTPS_PROXY pointing at
-        the egress daemon) is inherited by the child. Non-zero
+        the egress sidecar) is inherited by the child. Non-zero
         exit does not raise — callers inspect `returncode`
         themselves.
 
@@ -454,7 +454,7 @@ class BottleBackend(ABC, Generic[PlanT, CleanupT]):
         declarative provision-plan apply, supervise MCP registration)
         live on the `AgentProvider` plugin. The backend only owns the
         steps that are about backend infrastructure (CA, workspace,
-        git) and surfaces the supervise daemon URL its launch step
+        git) and surfaces the supervise sidecar URL its launch step
         knows about via `supervise_mcp_url`.
 
         PRD 0017: cred-proxy's agent-side dotfile rewrites (~/.npmrc,
@@ -502,7 +502,7 @@ class BottleBackend(ABC, Generic[PlanT, CleanupT]):
 
     def supervise_mcp_url(self, plan: PlanT) -> str:
         """Return the agent-side URL of the per-bottle supervise
-        gateway, or "" when this bottle has no gateway. The provider
+        sidecar, or "" when this bottle has no sidecar. The provider
         plugin's `provision_supervise_mcp` uses it to register the
         MCP entry inside the guest.
 
@@ -511,18 +511,6 @@ class BottleBackend(ABC, Generic[PlanT, CleanupT]):
         del plan
         return ""
 
-    def ensure_orchestrator(self) -> str:
-        """Bring up this backend's per-host orchestrator + shared gateway
-        (idempotent) and return the host-reachable control-plane URL.
-
-        This is the backend-agnostic bring-up entry point: `launch` calls
-        it as part of starting a bottle, and operator tools (`supervise`)
-        call it to start the control plane on demand when none is running
-        yet. Docker starts the orchestrator + gateway containers;
-        firecracker boots the infra VM. Backends with no orchestrator
-        (macos-container) die with a pointer — the default here."""
-        die(f"backend {self.name!r} has no orchestrator control plane")
-
     @abstractmethod
     def prepare_cleanup(self) -> CleanupT:
         """Enumerate orphaned resources from previous bottles. No side
@@ -536,7 +524,7 @@ class BottleBackend(ABC, Generic[PlanT, CleanupT]):
     def enumerate_active(self) -> Sequence[ActiveAgent]:
         """Return every currently-running agent on this backend.
         Empty when none. Backend-specific: docker queries `docker
-        compose ls`; firecracker cross-references its running gateway
+        compose ls`; firecracker cross-references its running sidecar
         containers against per-bottle metadata."""
 
     @classmethod

bot_bottle/backend/docker/backend.py

@@ -105,21 +105,12 @@ class DockerBottleBackend(BottleBackend["DockerBottlePlan", "DockerBottleCleanup
         with _launch.launch(plan, provision=self.provision) as bottle:
             yield bottle
 
-    def ensure_orchestrator(self) -> str:
-        from ...orchestrator.lifecycle import OrchestratorService
-        return OrchestratorService().ensure_running()
-
     def supervise_mcp_url(self, plan: DockerBottlePlan) -> str:
-        """Docker bottles reach the supervise daemon via the
+        """Docker bottles reach the supervise sidecar via the
         compose-network alias `supervise:9100`. No per-bottle URL
         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,34 +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 = ""
-    # Per-bottle identity token the agent presents on every attributed request
-    # (egress proxy credentials, git-gate/supervise headers); set by launch
-    # from the orchestrator registration. Empty pre-registration.
-    identity_token: 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/compose.py

@@ -1,10 +1,20 @@
-"""Docker compose lifecycle helpers (PRD 0018).
+"""Compose-spec rendering for a Docker bottle (PRD 0018, chunk 1).
 
-Serialize a compose spec to disk, drive `docker compose up/down`,
+`bottle_plan_to_compose(plan)` returns a Compose v2 spec dict
-dump the merged log on teardown, and enumerate `bot-bottle-*`
+describing the per-bottle container topology — one project per
-projects. The spec itself is built by `consolidated_compose.py`
+bottle instance, services for the agent + every applicable sidecar,
-(the consolidated per-host gateway topology); this module owns the
+two networks, no named volumes.
-I/O side that persists and runs it.
+
+Pure function. No I/O, no subprocess. Expects every launch-time
+field (network names, CA host paths, etc.) on the plan's inner
+plans to be populated; chunks 2+3 own that ordering.
+
+Conditional services follow the plan content:
+
+  - agent + sidecars bundle: always.
+  - git-gate:  iff plan.git_gate_plan.upstreams.
+  - egress:    iff plan.egress_plan.routes.
+  - supervise: iff plan.supervise_plan is not None.
 """
 
 from __future__ import annotations
@@ -15,7 +25,233 @@ import sys
 from pathlib import Path
 from typing import Any
 
+from ...egress import (
+    EGRESS_HOSTNAME,
+    EGRESS_ROUTES_IN_CONTAINER,
+    egress_agent_env_entries,
+    egress_sidecar_env_entries,
+)
+from ...git_gate import GIT_GATE_HOSTNAME
 from ...log import die, warn
+from ...supervise import (
+    DB_PATH_IN_CONTAINER,
+    SUPERVISE_HOSTNAME,
+    SUPERVISE_PORT,
+)
+from ...util import expand_tilde
+from ..util import AGENT_CA_BUNDLE, AGENT_CA_PATH
+from .bottle_plan import DockerBottlePlan
+from .egress import (
+    EGRESS_CA_IN_CONTAINER,
+    EGRESS_PORT,
+)
+from .git_gate import (
+    GIT_GATE_ACCESS_HOOK_IN_CONTAINER,
+    GIT_GATE_CREDS_DIR_IN_CONTAINER,
+    GIT_GATE_ENTRYPOINT_IN_CONTAINER,
+    GIT_GATE_HOOK_IN_CONTAINER,
+)
+from . import network as network_mod
+from .sidecar_bundle import (
+    SIDECAR_BUNDLE_DOCKERFILE,
+    SIDECAR_BUNDLE_IMAGE,
+    sidecar_bundle_container_name,
+)
+
+
+# Repo root, used as the build context for the bundle Dockerfile.
+_REPO_DIR = str(Path(__file__).resolve().parent.parent.parent.parent)
+
+
+def bottle_plan_to_compose(plan: DockerBottlePlan) -> dict[str, Any]:
+    """Render a Compose v2 spec dict from a fully-resolved
+    DockerBottlePlan.
+
+    The plan must have its inner plans (`git_gate_plan`,
+    `egress_plan`, `supervise_plan`) populated with launch-time
+    fields — network names, CA host paths. The renderer doesn't
+    validate; callers feed it a fully-resolved plan or get an
+    incomplete compose spec back.
+    """
+    project = f"bot-bottle-{plan.slug}"
+    services: dict[str, Any] = {
+        "sidecars": _sidecar_bundle_service(plan),
+        "agent": _agent_service(plan),
+    }
+    return {
+        "name": project,
+        "services": services,
+        "networks": _networks(plan),
+    }
+
+
+def _networks(plan: DockerBottlePlan) -> dict[str, Any]:
+    """Compose-managed networks with explicit `name:` matching the
+    existing slug-suffixed convention. Compose creates them on `up`
+    and destroys them on `down`. The internal one is `--internal`
+    (no default gateway); the egress one is a normal user-defined
+    bridge."""
+    return {
+        "internal": {
+            "name": network_mod.network_name_for_slug(plan.slug),
+            "internal": True,
+        },
+        "egress": {
+            "name": network_mod.network_egress_name_for_slug(plan.slug),
+        },
+    }
+
+
+def _bind(host: str | Path, target: str, *, read_only: bool = True) -> dict[str, Any]:
+    """One bind-mount entry in the long-form `volumes:` shape.
+    Long form is preferred over `host:target:ro` strings because
+    it's easier to inspect in tests and survives whitespace in
+    host paths."""
+    return {
+        "type": "bind",
+        "source": str(host),
+        "target": target,
+        "read_only": read_only,
+    }
+
+
+def _sidecar_bundle_service(plan: DockerBottlePlan) -> dict[str, Any]:
+    """The `sidecars` service: one container per bottle, bundle
+    image, all daemons under a Python init supervisor.
+
+    Daemon subset narrows via `BOT_BOTTLE_SIDECAR_DAEMONS` env.
+    egress is always present; git-gate / supervise are conditional.
+    """
+    daemons: list[str] = ["egress"]
+    if plan.git_gate_plan.upstreams:
+        daemons.append("git-gate")
+    if plan.supervise_plan is not None:
+        daemons.append("supervise")
+
+    env: list[str] = [f"BOT_BOTTLE_SIDECAR_DAEMONS={','.join(daemons)}"]
+    volumes: list[dict[str, Any]] = []
+
+    # --- egress -------------------------------------------------------
+    ep = plan.egress_plan
+    volumes.append(_bind(ep.mitmproxy_ca_host_path, EGRESS_CA_IN_CONTAINER))
+    if ep.routes:
+        volumes.append(_bind(ep.routes_path.parent, str(Path(EGRESS_ROUTES_IN_CONTAINER).parent)))
+    env.extend(egress_sidecar_env_entries(ep))
+
+    # --- git-gate -----------------------------------------------------
+    gp = plan.git_gate_plan
+    if gp.upstreams:
+        volumes += [
+            _bind(gp.entrypoint_script, GIT_GATE_ENTRYPOINT_IN_CONTAINER),
+            _bind(gp.hook_script, GIT_GATE_HOOK_IN_CONTAINER),
+            _bind(gp.access_hook_script, GIT_GATE_ACCESS_HOOK_IN_CONTAINER),
+        ]
+        for u in gp.upstreams:
+            keypath = expand_tilde(u.identity_file)
+            volumes.append(_bind(
+                keypath,
+                f"{GIT_GATE_CREDS_DIR_IN_CONTAINER}/{u.name}-key",
+            ))
+            if u.known_hosts_file:
+                volumes.append(_bind(
+                    u.known_hosts_file,
+                    f"{GIT_GATE_CREDS_DIR_IN_CONTAINER}/{u.name}-known_hosts",
+                ))
+
+    # --- supervise ----------------------------------------------------
+    sp = plan.supervise_plan
+    if sp is not None:
+        env += [
+            f"SUPERVISE_BOTTLE_SLUG={plan.slug}",
+            f"SUPERVISE_DB_PATH={DB_PATH_IN_CONTAINER}",
+            f"SUPERVISE_PORT={SUPERVISE_PORT}",
+        ]
+        volumes.append({
+            "type": "bind",
+            "source": str(sp.db_path),
+            "target": DB_PATH_IN_CONTAINER,
+            "read_only": False,
+        })
+    internal_aliases = [EGRESS_HOSTNAME]
+    if gp.upstreams:
+        internal_aliases.append(GIT_GATE_HOSTNAME)
+    if sp is not None:
+        internal_aliases.append(SUPERVISE_HOSTNAME)
+
+    service: dict[str, Any] = {
+        "image": SIDECAR_BUNDLE_IMAGE,
+        "build": {
+            "context": _REPO_DIR,
+            "dockerfile": SIDECAR_BUNDLE_DOCKERFILE,
+        },
+        "container_name": sidecar_bundle_container_name(plan.slug),
+        "networks": {
+            "internal": {"aliases": internal_aliases},
+            "egress": None,
+        },
+        "environment": env,
+        "volumes": volumes,
+    }
+    return service
+
+
+def _agent_service(plan: DockerBottlePlan) -> dict[str, Any]:
+    """Agent container. Runs `sleep infinity`; claude is `docker
+    exec -it`'d into it later. HTTP_PROXY/HTTPS_PROXY point at the
+    egress sidecar."""
+    proxy_url = _agent_proxy_url(plan)
+    no_proxy = _agent_no_proxy(plan)
+    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 (OAuth token, manifest host-interpolations):
+    # bare name → inherits from compose-up process env, 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"],
+        "networks": {"internal": None},
+        "environment": env,
+    }
+    if plan.use_runsc:
+        service["runtime"] = "runsc"
+
+    # The init supervisor inside the bundle owns intra-bundle
+    # daemon ordering, so the agent only waits for the bundle
+    # container itself.
+    service["depends_on"] = ["sidecars"]
+
+    return service
+
+
+def _agent_proxy_url(plan: DockerBottlePlan) -> str:
+    """Agent's HTTP_PROXY — always points at egress."""
+    return f"http://{EGRESS_HOSTNAME}:{EGRESS_PORT}"
+
+
+def _agent_no_proxy(plan: DockerBottlePlan) -> str:
+    """NO_PROXY for the agent: loopback always; supervise hostname
+    when the supervise sidecar is up (MCP long-poll must bypass
+    the egress proxy)."""
+    hosts = ["localhost", "127.0.0.1"]
+    if plan.supervise_plan is not None:
+        hosts.append(SUPERVISE_HOSTNAME)
+    return ",".join(hosts)
 
 
 # --- Lifecycle helpers (PRD 0018 chunk 3) ----------------------------------
@@ -206,6 +442,7 @@ __all__ = [
     "COMPOSE_FILE_NAME",
     "COMPOSE_LOG_NAME",
     "COMPOSE_PROJECT_PREFIX",
+    "bottle_plan_to_compose",
     "compose_down",
     "compose_dump_logs",
     "compose_file_path",

bot_bottle/backend/docker/consolidated_compose.py

@@ -1,84 +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
-gateway on two per-bottle networks. In the consolidated model the
-per-bottle companion containers 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`."""
-    # Deliver the identity token as egress proxy credentials — the gateway
-    # reads Proxy-Authorization, validates the (source_ip, token) pair, and
-    # strips it before upstream. git-http/supervise get it via their own
-    # headers (git config extraHeader / MCP header).
-    token = getattr(plan, "identity_token", "")
-    cred = f"bottle:{token}@" if token else ""
-    proxy_url = f"http://{cred}{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,158 +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 gateway:
-
-  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 (
-    DockerGatewayTransport,
-    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(
-            DockerGatewayTransport(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(DockerGatewayTransport(gateway_name), bottle_id)
-
-
-__all__ = [
-    "LaunchContext",
-    "launch_consolidated",
-    "teardown_consolidated",
-    "ConsolidatedLaunchError",
-]

bot_bottle/backend/docker/egress.py

@@ -4,7 +4,7 @@ prepare-time routes-yaml rendering itself lives on the
 platform-neutral `Egress` ABC — backends instantiate it directly.
 
 The per-container `.start()` / `.stop()` lifecycle was removed in
-PRD 0024 chunk 3; the gateway (PRD 0024) runs egress
+PRD 0024 chunk 3; the sidecar bundle (PRD 0024) runs egress
 under its python init supervisor."""
 
 from __future__ import annotations

bot_bottle/backend/docker/egress_apply.py

@@ -1,29 +1,60 @@
-"""Host-side egress route-apply for the docker backend.
+"""Host-side helper for egress sidecar inspection and live updates.
 
-The per-bottle companion container this used to signal (`docker kill
+The approve path uses this module to validate a proposed routes file,
---signal HUP <container>`) was removed in the companion-container removal (#385).
+write it to the bottle's live egress state dir, and signal the sidecar
-In the consolidated model the shared gateway resolves egress policy
+bundle so the mitmproxy addon reloads it.
-per-request against the orchestrator rather than reloading a per-bottle
-routes file, so the live per-bottle reload is not supported here and
-fails closed until the gateway-side apply lands.
 """
 
 from __future__ import annotations
 
+import os
+import subprocess
+
+from ...egress import EGRESS_ROUTES_IN_CONTAINER
+from ...log import warn
 from ..egress_apply import EgressApplicator, EgressApplyError
+from .sidecar_bundle import sidecar_bundle_container_name
+
+
+def fetch_current_routes(slug: str) -> str:
+    container = sidecar_bundle_container_name(slug)
+    r = subprocess.run(
+        ["docker", "exec", container, "cat", EGRESS_ROUTES_IN_CONTAINER],
+        capture_output=True, text=True, check=False,
+    )
+    if r.returncode != 0:
+        raise EgressApplyError(
+            f"could not read routes.yaml from {container}: "
+            f"{(r.stderr or '').strip() or 'container not running?'}"
+        )
+    return r.stdout
 
 
 class DockerEgressApplicator(EgressApplicator):
     def _signal_bundle_reload(self, slug: str) -> None:
-        del slug
+        container = sidecar_bundle_container_name(slug)
+        result = subprocess.run(
+            ["docker", "kill", "--signal", "HUP", container],
+            capture_output=True, text=True, check=False, env=os.environ,
+        )
+        if result.returncode != 0:
+            last_error = (result.stderr or "").strip() or (result.stdout or "").strip()
+            warn(
+                f"egress: routes updated on disk for {slug}, but bundle reload failed: "
+                f"{last_error or 'docker kill failed'}"
+            )
             raise EgressApplyError(
-            "live egress route-apply was removed with the per-bottle "
+                f"could not reload egress bundle {container}: "
-            "companion container (#385); route changes will flow through "
+                f"{last_error or 'docker kill failed'}"
-            "the consolidated gateway in a follow-up."
             )
 
 
 applicator = DockerEgressApplicator()
 
 
-__all__ = ["DockerEgressApplicator", "EgressApplyError", "applicator"]
+__all__ = [
+    "DockerEgressApplicator",
+    "EgressApplyError",
+    "applicator",
+    "fetch_current_routes",
+]

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,126 +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 typing import Protocol
-
-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
-# exec/cp path arguments, so validate before any path is built (a traversal
-# id like "../etc" must never reach the gateway). Registry ids are token_hex —
-# this is defense in depth at the transport boundary.
-_SAFE_BOTTLE_ID = re.compile(r"[A-Za-z0-9_-]+")
-
-
-class GatewayProvisionError(RuntimeError):
-    """A git-gate provisioning step against the running gateway failed."""
-
-
-class GatewayTransport(Protocol):
-    """How the launcher stages files + runs commands in the running gateway.
-    Backend-neutral so the same provisioning logic serves the docker gateway
-    (exec/cp over the docker socket) and the firecracker gateway VM (over
-    SSH)."""
-
-    def exec(self, argv: list[str]) -> None:
-        """Run `argv` in the gateway, raising `GatewayProvisionError` on
-        failure."""
-
-    def cp_into(self, src: str, dest: str) -> None:
-        """Copy host file `src` to `dest` in the gateway, raising on
-        failure."""
-
-
-class DockerGatewayTransport:
-    """`GatewayTransport` for the docker gateway container (exec/cp)."""
-
-    def __init__(self, gateway: str) -> None:
-        self.gateway = gateway
-
-    def exec(self, argv: list[str]) -> None:
-        proc = run_docker(["docker", "exec", self.gateway, *argv])
-        if proc.returncode != 0:
-            raise GatewayProvisionError(
-                f"gateway exec {argv!r} failed: {proc.stderr.strip()}"
-            )
-
-    def cp_into(self, src: str, dest: str) -> None:
-        proc = run_docker(["docker", "cp", src, f"{self.gateway}:{dest}"])
-        if proc.returncode != 0:
-            raise GatewayProvisionError(
-                f"gateway cp {src} -> {dest} failed: {proc.stderr.strip()}"
-            )
-
-
-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 provision_git_gate(
-    transport: GatewayTransport, bottle_id: str, plan: GitGatePlan,
-) -> None:
-    """Place `bottle_id`'s git-gate credentials into the running gateway 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.
-    transport.exec(["mkdir", "-p", "/etc/git-gate"])
-    transport.cp_into(str(plan.hook_script), "/etc/git-gate/pre-receive")
-    transport.cp_into(str(plan.access_hook_script), "/etc/git-gate/access-hook")
-    creds = _creds_dir(bottle_id)
-    transport.exec(["mkdir", "-p", creds])
-    for u in plan.upstreams:
-        if u.identity_file:
-            transport.cp_into(u.identity_file, f"{creds}/{u.name}-key")
-        known_hosts = str(u.known_hosts_file)
-        if known_hosts and known_hosts != ".":
-            transport.cp_into(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)
-    transport.exec(["sh", "-c", script])
-
-
-def deprovision_git_gate(transport: GatewayTransport, 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)
-    try:
-        transport.exec([
-            "rm", "-rf", f"/git/{bottle_id}", _creds_dir(bottle_id),
-        ])
-    except GatewayProvisionError:
-        pass  # best-effort teardown; absent namespace is success
-
-
-__all__ = [
-    "provision_git_gate", "deprovision_git_gate",
-    "GatewayProvisionError", "GatewayTransport", "DockerGatewayTransport",
-]

bot_bottle/backend/docker/git_gate.py

@@ -2,7 +2,7 @@
 bind-mounts target + the listening port. The prepare-time entrypoint
 / hook render lives on the platform-neutral `GitGate` ABC — backends
 instantiate it directly. The git-gate daemon's container lifecycle
-is owned by the gateway (PRD 0024)."""
+is owned by the sidecar bundle (PRD 0024)."""
 
 from __future__ import annotations
 

bot_bottle/backend/docker/launch.py

@@ -5,7 +5,7 @@ PRD 0018 chunk 3: each instance is one `docker compose` project.
 The flow is:
 
   1. Build the agent image from the provider Dockerfile (compose
-     builds the gateway image on first up).
+     builds the sidecar images via the `build:` directive on first up).
   2. Mint the per-bottle egress CA (chunk 2 writes it under
      state/<slug>/egress/).
   3. Populate the inner plans with launch-time fields so the
@@ -36,13 +36,13 @@ from contextlib import ExitStack, contextmanager
 from pathlib import Path
 from typing import Callable, Generator
 
-from ...agent_provider import runtime_for
 from ...egress import egress_resolve_token_values
 from ...git_gate import (
     provision_git_gate_dynamic_keys,
     revoke_git_gate_provisioned_keys,
 )
 from ...log import info, warn
+from . import network as network_mod
 from . import util as docker_mod
 from .bottle import DockerBottle
 from .bottle_plan import DockerBottlePlan
@@ -53,6 +53,7 @@ from ...bottle_state import (
     read_committed_image,
 )
 from .compose import (
+    bottle_plan_to_compose,
     compose_down,
     compose_dump_logs,
     compose_file_path,
@@ -61,9 +62,7 @@ from .compose import (
     compose_up,
     write_compose_file,
 )
-from .consolidated_compose import consolidated_agent_compose
+from .egress import egress_tls_init
-from .consolidated_launch import launch_consolidated, teardown_consolidated
-from ...orchestrator.gateway import DockerGateway
 
 
 # Where the repo root lives, for `docker build` context. Computed once.
@@ -98,7 +97,8 @@ def launch(
     try:
         # Step 1: agent image. Use a committed snapshot when one exists
         # and is present in the local daemon; otherwise build from the
-        # Dockerfile. (The gateway image is built by the orchestrator.)
+        # Dockerfile. Sidecar images get built lazily by `docker compose
+        # up` via the renderer's `build:` directives.
         committed = read_committed_image(plan.slug)
         if committed and docker_mod.image_exists(committed):
             info(f"using committed image {committed!r}")
@@ -111,87 +111,83 @@ def launch(
                 plan.image, _REPO_DIR,
                 dockerfile=plan.dockerfile_path,
             )
-            docker_mod.verify_agent_image(
+
-                plan.image, runtime_for(plan.agent_provider_template).smoke_test,
+        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),
         )
 
-        # Step 2: mint the git-gate dynamic (gitea) deploy keys, if any, before
-        # provisioning the bottle's repos into the shared gateway.
         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(
-        # Step 3: register on the orchestrator + provision this bottle's
+                git_gate_plan,
-        # git-gate state into the shared gateway; get the agent's attach
+                internal_network=internal_network,
-        # context (pinned source IP, gateway address, shared network). The
+                egress_network=egress_network,
-        # 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,
+            internal_network=internal_network,
-            mitmproxy_ca_cert_only_host_path=ca_file,
+            egress_network=egress_network,
+            mitmproxy_ca_host_path=egress_ca_host,
+            mitmproxy_ca_cert_only_host_path=egress_ca_cert_only,
         )
-        # Point the agent's git-gate insteadOf rewrites at the shared gateway's
+        supervise_plan = plan.supervise_plan
-        # HTTP git endpoint (9420) instead of the dead per-bottle `git-gate`
+        if supervise_plan is not None:
-        # alias. git-http + supervise on the gateway bypass the egress proxy
+            supervise_plan = dataclasses.replace(
-        # (NO_PROXY includes the gateway address).
+                supervise_plan,
-        git_gate_url = (
+                internal_network=internal_network,
-            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 ""
             )
         plan = dataclasses.replace(
             plan,
             git_gate_plan=git_gate_plan,
             egress_plan=egress_plan,
-            agent_git_gate_url=git_gate_url,
+            supervise_plan=supervise_plan,
-            agent_supervise_url=supervise_url,
-            identity_token=ctx.identity_token,
         )
 
-        # Step 5: render + up the agent-only compose, pinned on the shared
+        # Step 6: render + write the compose file. metadata.json
-        # gateway network and proxied through the gateway's address.
+        # 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(
+        spec = bottle_plan_to_compose(plan)
-            plan, gateway_ip=ctx.gateway_ip, source_ip=ctx.source_ip, network=ctx.network,
-        )
         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.
+        # Step 7: compose up. Token values + the OAuth placeholder
-        compose_env: dict[str, str] = {**os.environ, **plan.forwarded_env}
+        # 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"docker compose up -d  (project {project}, "
-            f"gateway {ctx.gateway_ip}, ip {ctx.source_ip})"
+            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,
@@ -204,6 +200,10 @@ def launch(
             agent_workdir=plan.workspace_plan.workdir,
         )
         bottle.prompt_path = provision(plan, bottle)
+
+        # Step 9: yield. exec_agent continues to use `docker exec -it`
+        # — the agent runs `sleep infinity` per the renderer's
+        # service spec.
         yield bottle
     finally:
         teardown()

bot_bottle/backend/docker/network.py

@@ -76,7 +76,7 @@ def network_create_internal(slug: str) -> str:
 
 def network_create_egress(slug: str) -> str:
     """Create a per-agent user-defined bridge (NOT the legacy `bridge`)
-    so the egress daemon has working DNS for upstream hostnames."""
+    so the egress sidecar has working DNS for upstream hostnames."""
     return _network_create_with_prefix(network_egress_name_for_slug(slug), internal=False)
 
 

bot_bottle/backend/docker/setup.py

@@ -1,7 +1,7 @@
 """Host setup + status for the Docker backend.
 
 Unlike Firecracker, the Docker backend needs no privileged one-time
-host provisioning (no TAP pool / nft table) — networks and the gateway
+host provisioning (no TAP pool / nft table) — networks and the sidecar
 bundle are created per-launch. So `setup()` is mostly an install/daemon
 pointer, and `status()` reports whether docker is usable.
 
@@ -45,7 +45,7 @@ def setup() -> int:
         return 1
     sys.stderr.write(
         "Docker backend: no privileged host setup required — networks and "
-        "the gateway are created per-launch.\n"
+        "the sidecar bundle are created per-launch.\n"
     )
     if not _daemon_reachable():
         sys.stderr.write(
@@ -64,7 +64,7 @@ def setup() -> int:
 def teardown() -> int:
     sys.stderr.write(
         "Docker backend: nothing to undo — it provisions no privileged host "
-        "state (networks and the gateway are per-launch and are "
+        "state (networks and the sidecar bundle are per-launch and are "
         "removed by `./cli.py cleanup`). Docker itself is left installed.\n"
     )
     return 0

bot_bottle/backend/docker/sidecar_bundle.py

@@ -0,0 +1,30 @@
+"""Sidecar bundle constants + helpers for the Docker backend
+(PRD 0024).
+
+The bundle image (built by Dockerfile.sidecars, PRD 0024 chunk 1)
+runs egress + git-gate + supervise as one container per bottle
+under a small Python init supervisor. As of chunk 5 the bundle
+is the only shape — the legacy four-sidecar topology and its
+`BOT_BOTTLE_SIDECAR_BUNDLE` feature flag are gone."""
+
+from __future__ import annotations
+
+import os
+
+
+# Bundle image. Defaults to a built-locally tag (built from the
+# repo's Dockerfile.sidecars via compose `build:`). Operators
+# pinning to a published digest can override via env.
+SIDECAR_BUNDLE_IMAGE = os.environ.get(
+    "BOT_BOTTLE_SIDECAR_IMAGE",
+    "bot-bottle-sidecars:latest",
+)
+
+SIDECAR_BUNDLE_DOCKERFILE = "Dockerfile.sidecars"
+
+
+def sidecar_bundle_container_name(slug: str) -> str:
+    """`bot-bottle-sidecars-<slug>`. Same prefix scheme as the
+    per-sidecar containers it replaces, so the dashboard's
+    discovery-by-prefix logic keeps working."""
+    return f"bot-bottle-sidecars-{slug}"

bot_bottle/backend/docker/util.py

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

bot_bottle/backend/firecracker/backend.py

@@ -110,7 +110,3 @@ class FirecrackerBottleBackend(
 
     def supervise_mcp_url(self, plan: FirecrackerBottlePlan) -> str:
         return plan.agent_supervise_url
-
-    def ensure_orchestrator(self) -> str:
-        from . import infra_vm
-        return infra_vm.ensure_running().control_plane_url

bot_bottle/backend/firecracker/bottle.py

@@ -7,7 +7,7 @@ session. `ssh -t` forwards the host terminal's SIGWINCH to the remote
 PTY natively, so no separate resize bridge is needed.
 
 Commands run as the image's `node` user via `runuser`, with HOME/USER/
-PATH and the bottle env (HTTPS_PROXY at the gateway, CA paths, …) set
+PATH and the bottle env (HTTPS_PROXY at the sidecar, CA paths, …) set
 per-invocation through `env` (the VM itself just runs the init; it has
 no baked-in process env like a `docker run` container would).
 """
@@ -105,9 +105,10 @@ class FirecrackerBottle(Bottle):
         # root-owned and unreadable by node, which breaks Node's
         # process.cwd(), the shell-snapshot machinery, and `/doctor`.
         # Use `env --chdir` rather than a `sh -c 'cd … && exec "$@"'`
-        # wrapper: it keeps the guest command a flat argv that `agent_argv`
+        # wrapper: ssh space-joins everything after the host into one
-        # can quote token-by-token for the ssh→guest-shell round trip,
+        # string for the guest shell, so a quoted script + $@ would be
-        # avoiding a fragile nested-quoting `"$@"` script.
+        # re-split and mangled (exec'ing the $0 placeholder). All-simple
+        # words survive that join.
         workdir = self.agent_workdir or _HOME_FOR["node"]
         remote = ["runuser", "-u", "node", "--",
                   "env", f"--chdir={workdir}",
@@ -116,15 +117,7 @@ class FirecrackerBottle(Bottle):
         return remote
 
     def agent_argv(self, argv: list[str], *, tty: bool = True) -> list[str]:
-        # ssh space-joins everything after the host into one line the guest
+        return [*self._ssh(tty=tty), "--", *self._agent_remote_argv(argv)]
-        # shell re-parses, so pre-quote each remote token for that shell.
-        # Simple words are unchanged (existing behaviour); an arg containing
-        # spaces — e.g. codex's `read_prompt_file` positional "Read and follow
-        # the instructions in <path>." — is quoted so it survives as ONE
-        # argument instead of being re-split (which made codex parse "and" as
-        # a subcommand).
-        remote = self._agent_remote_argv(argv)
-        return [*self._ssh(tty=tty), "--", *(shlex.quote(t) for t in remote)]
 
     def exec_agent(self, argv: list[str], *, tty: bool = True) -> int:
         agent_argv = self.agent_argv(argv, tty=tty)

bot_bottle/backend/firecracker/bottle_cleanup_plan.py

@@ -10,9 +10,10 @@ from .. import BottleCleanupPlan
 
 @dataclass(frozen=True)
 class FirecrackerBottleCleanupPlan(BottleCleanupPlan):
-    # PIDs of orphaned firecracker VMM processes and the per-bottle run
+    # PIDs of orphaned firecracker VMM processes and the sidecar
-    # dirs left behind by previous bottles.
+    # containers left behind by previous bottles.
     vm_pids: tuple[int, ...] = ()
+    containers: tuple[str, ...] = ()
     run_dirs: tuple[str, ...] = ()
 
     def print(self) -> None:
@@ -21,9 +22,11 @@ class FirecrackerBottleCleanupPlan(BottleCleanupPlan):
             return
         for pid in self.vm_pids:
             info(f"firecracker VM process: pid {pid}")
+        for name in self.containers:
+            info(f"firecracker sidecar container: {name}")
         for path in self.run_dirs:
             info(f"firecracker run dir: {path}")
 
     @property
     def empty(self) -> bool:
-        return not (self.vm_pids or self.run_dirs)
+        return not (self.vm_pids or self.containers or self.run_dirs)

bot_bottle/backend/firecracker/bottle_plan.py

@@ -13,19 +13,15 @@ from .. import BottlePlan
 class FirecrackerBottlePlan(BottlePlan):
     slug: str
     forwarded_env: dict[str, str] = field(repr=False)
-    # Stamped by launch once the gateway is up and its ports are
+    # Stamped by launch once the sidecar is up and its ports are
     # published on the host-side TAP IP (empty at prepare time).
     agent_proxy_url: str = ""
     agent_git_gate_url: str = ""
     agent_supervise_url: str = ""
-    # Per-bottle identity token the agent presents on every attributed request
-    # (egress proxy credentials, git-gate/supervise headers); set by launch
-    # from the orchestrator registration. Empty pre-registration.
-    identity_token: str = ""
 
     @property
     def container_name(self) -> str:
-        """Instance name, reused for the gateway container + VM run dir.
+        """Instance name, reused for the sidecar container + VM run dir.
         Matches the `bot-bottle-<slug>` convention the other backends
         use so cleanup/enumerate discovery-by-prefix keeps working."""
         return self.agent_provision.instance_name

bot_bottle/backend/firecracker/cleanup.py

@@ -1,8 +1,9 @@
 """Cleanup for the Firecracker backend.
 
 Orphans are: firecracker VMM processes whose config lives under our run
-dir, and the per-bottle run dirs. TAP slots free themselves (the flock
+dir, the `bot-bottle-sidecars-*` containers, and the per-bottle run
-drops when the launcher exits), so there is nothing to reclaim there.
+dirs. TAP slots free themselves (the flock drops when the launcher
+exits), so there is nothing to reclaim there.
 """
 
 from __future__ import annotations
@@ -17,6 +18,8 @@ from ...log import info
 from . import util
 from .bottle_cleanup_plan import FirecrackerBottleCleanupPlan
 
+_SIDECAR_PREFIX = "bot-bottle-sidecars-"
+
 
 def _run_root() -> Path:
     return util.cache_dir() / "run"
@@ -43,6 +46,17 @@ def _orphan_vm_pids() -> list[int]:
     return pids
 
 
+def _sidecar_containers() -> list[str]:
+    result = subprocess.run(
+        ["docker", "ps", "-a", "--format", "{{.Names}}",
+         "--filter", f"name={_SIDECAR_PREFIX}"],
+        capture_output=True, text=True, check=False,
+    )
+    if result.returncode != 0:
+        return []
+    return sorted(n.strip() for n in result.stdout.splitlines() if n.strip())
+
+
 def _run_dirs() -> list[str]:
     run_root = _run_root()
     if not run_root.is_dir():
@@ -53,6 +67,7 @@ def _run_dirs() -> list[str]:
 def prepare_cleanup() -> FirecrackerBottleCleanupPlan:
     return FirecrackerBottleCleanupPlan(
         vm_pids=tuple(_orphan_vm_pids()),
+        containers=tuple(_sidecar_containers()),
         run_dirs=tuple(_run_dirs()),
     )
 
@@ -64,6 +79,12 @@ def cleanup(plan: FirecrackerBottleCleanupPlan) -> None:
             os.kill(pid, signal.SIGTERM)
         except ProcessLookupError:
             pass
+    for name in plan.containers:
+        info(f"docker rm -f {name}")
+        subprocess.run(
+            ["docker", "rm", "-f", name],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False,
+        )
     for path in plan.run_dirs:
         info(f"rm -rf {path}")
         shutil.rmtree(path, ignore_errors=True)

bot_bottle/backend/firecracker/consolidated_launch.py

@@ -1,109 +0,0 @@
-"""Consolidated bottle launch sequence for the Firecracker backend
-(PRD 0070, Stage B).
-
-The shared gateway + orchestrator control plane run in a single persistent
-per-host **infra VM** (`infra_vm.py`), not Docker containers. Agent VMs reach
-the gateway's egress / supervise / git-http ports at the infra VM via a
-PREROUTING DNAT on their own host-side TAP IP (see
-`scripts/firecracker-netpool.sh`), and the host CLI reaches the control plane
-over HTTP at the infra VM's guest IP.
-
-Attribution is by the agent VM's guest IP, unspoofable by construction: the
-/31 point-to-point TAP + the `bot_bottle_fc` nft table ensure only the
-expected VM can source-IP that address.
-
-Sequence:
-  1. ensure the infra VM (control plane + gateway) is up (a singleton — a
-     prior launcher may already have booted it);
-  2. register the bottle by its guest IP (attribution key) → bottle id +
-     identity token;
-  3. provision its git-gate repos/creds into the gateway VM (over SSH);
-  4. fetch the shared gateway CA for the provisioner to install in the rootfs.
-
-The TAP slot allocation, rootfs build, and VM boot are the caller's job.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from ...egress import EgressPlan
-from ...git_gate import GitGatePlan
-from ...orchestrator.client import OrchestratorClient
-from ...orchestrator.lifecycle import (
-    OrchestratorStartError,  # re-exported so callers can catch it
-)
-from ...orchestrator.registration import registration_inputs
-from ..docker.gateway_provision import deprovision_git_gate, provision_git_gate
-from . import infra_vm
-
-
-class ConsolidatedLaunchError(RuntimeError):
-    """The consolidated register/provision sequence could not complete."""
-
-
-@dataclass(frozen=True)
-class LaunchContext:
-    """What the Firecracker launch needs from the consolidated sequence."""
-
-    bottle_id: str
-    identity_token: str
-    source_ip: str          # the VM's guest IP — the attribution key
-    gateway_ca_pem: str     # the shared gateway CA the provisioner installs
-    orchestrator_url: str
-
-
-def launch_consolidated(
-    egress_plan: EgressPlan,
-    git_gate_plan: GitGatePlan,
-    *,
-    guest_ip: str,
-    image_ref: str = "",
-    tokens: dict[str, str] | None = None,
-) -> LaunchContext:
-    """Ensure the infra VM is up, register the bottle by its guest IP, and
-    provision its git-gate state into the gateway VM. Returns the context the
-    agent-VM launch needs. Raises on failure — the caller tears down."""
-    infra = infra_vm.ensure_running()
-    url = infra.control_plane_url
-    client = OrchestratorClient(url)
-
-    inputs = registration_inputs(egress_plan)
-    reg = client.register_bottle(
-        guest_ip, image_ref=image_ref, policy=inputs.policy,
-        metadata=inputs.metadata, tokens=tokens,
-    )
-    try:
-        provision_git_gate(
-            infra_vm.gateway_transport(), reg.bottle_id, git_gate_plan)
-    except Exception:
-        client.teardown_bottle(reg.bottle_id)
-        raise
-
-    # The shared gateway CA every agent on this host trusts for TLS
-    # interception — fetched from the infra VM over SSH.
-    return LaunchContext(
-        bottle_id=reg.bottle_id,
-        identity_token=reg.identity_token,
-        source_ip=guest_ip,
-        gateway_ca_pem=infra.gateway_ca_pem(),
-        orchestrator_url=url,
-    )
-
-
-def teardown_consolidated(bottle_id: str, *, orchestrator_url: str) -> None:
-    """Deregister the bottle and remove its git-gate state from the gateway
-    VM. Both steps are idempotent so this is safe from a cleanup trap. Does
-    NOT stop the infra VM — it's a persistent per-host singleton shared by
-    every bottle."""
-    OrchestratorClient(orchestrator_url).teardown_bottle(bottle_id)
-    deprovision_git_gate(infra_vm.gateway_transport(), bottle_id)
-
-
-__all__ = [
-    "LaunchContext",
-    "launch_consolidated",
-    "teardown_consolidated",
-    "ConsolidatedLaunchError",
-    "OrchestratorStartError",
-]

bot_bottle/backend/firecracker/enumerate.py

@@ -1,14 +1,43 @@
 """Active-agent enumeration for the Firecracker backend.
 
-The backend is disabled during the companion-container removal (#385) — it can't
+The agent runs in a VM (no container to list), so a live bottle is
-launch bottles, so there are none to enumerate. Real enumeration returns
+identified by its running sidecar container `bot-bottle-sidecars-<slug>`
-with the backend's consolidated relaunch (#354).
+— the same discovery-by-prefix the other backends use.
 """
 
 from __future__ import annotations
 
+import subprocess
+
+from ...bottle_state import read_metadata
 from .. import ActiveAgent
 
+_SIDECAR_PREFIX = "bot-bottle-sidecars-"
+
 
 def enumerate_active() -> list[ActiveAgent]:
+    result = subprocess.run(
+        ["docker", "ps", "--format", "{{.Names}}",
+         "--filter", f"name={_SIDECAR_PREFIX}"],
+        capture_output=True, text=True, check=False,
+    )
+    if result.returncode != 0:
         return []
+    out: list[ActiveAgent] = []
+    for name in sorted(n.strip() for n in result.stdout.splitlines() if n.strip()):
+        slug = name[len(_SIDECAR_PREFIX):]
+        metadata = read_metadata(slug)
+        if metadata is None or metadata.backend != "firecracker":
+            # Skip sidecars owned by another backend (docker shares the
+            # container-name prefix).
+            continue
+        out.append(ActiveAgent(
+            backend_name="firecracker",
+            slug=slug,
+            agent_name=metadata.agent_name,
+            started_at=metadata.started_at,
+            services=(),
+            label=metadata.label,
+            color=metadata.color,
+        ))
+    return out

bot_bottle/backend/firecracker/firecracker_vm.py

@@ -78,32 +78,20 @@ def _config(
     vcpus: int,
     mem_mib: int,
     guest_mac: str,
-    data_drive: Path | None = None,
 ) -> dict[str, object]:
-    drives: list[dict[str, object]] = [
+    return {
+        "boot-source": {
+            "kernel_image_path": str(util.kernel_path()),
+            "boot_args": _boot_args(guest_ip, host_ip, pubkey),
+        },
+        "drives": [
             {
                 "drive_id": "rootfs",
                 "path_on_host": str(rootfs),
                 "is_root_device": True,
                 "is_read_only": False,
             }
-    ]
+        ],
-    # A second virtio-block device (guest /dev/vdb) — the infra VM's
-    # persistent registry "volume", a host-side ext4 file that outlives the
-    # ephemeral rootfs across VM restarts.
-    if data_drive is not None:
-        drives.append({
-            "drive_id": "data",
-            "path_on_host": str(data_drive),
-            "is_root_device": False,
-            "is_read_only": False,
-        })
-    return {
-        "boot-source": {
-            "kernel_image_path": str(util.kernel_path()),
-            "boot_args": _boot_args(guest_ip, host_ip, pubkey),
-        },
-        "drives": drives,
         "network-interfaces": [
             {
                 "iface_id": "eth0",
@@ -130,16 +118,9 @@ def boot(
     vcpus: int = 2,
     mem_mib: int = 2048,
     guest_mac: str = "06:00:AC:10:00:02",
-    detached: bool = False,
-    data_drive: Path | None = None,
 ) -> VmHandle:
     """Write the config and launch the VMM. Returns once the process is
-    spawned; callers wait for SSH readiness separately.
+    spawned; callers wait for SSH readiness separately."""
-
-    `detached` starts the VMM in its own session (`start_new_session`) so it
-    survives the launcher exiting — used for the persistent per-host infra
-    VM, which must outlive the short-lived `start` process (agent VMs stay
-    attached and are torn down with the launcher)."""
     run_dir.mkdir(parents=True, exist_ok=True)
     config_path = run_dir / "config.json"
     console_log = run_dir / "console.log"
@@ -147,7 +128,6 @@ def boot(
         _config(
             rootfs=rootfs, tap=tap, guest_ip=guest_ip, host_ip=host_ip,
             pubkey=pubkey, vcpus=vcpus, mem_mib=mem_mib, guest_mac=guest_mac,
-            data_drive=data_drive,
         ),
         indent=2,
     ))
@@ -157,7 +137,6 @@ def boot(
     process = subprocess.Popen(
         ["firecracker", "--no-api", "--config-file", str(config_path)],
         stdout=log_fh, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL,
-        start_new_session=detached,
     )
     return VmHandle(process=process, guest_ip=guest_ip, console_log=console_log)
 

bot_bottle/backend/firecracker/freezer.py

@@ -1,12 +1,9 @@
-"""FirecrackerFreezer — snapshot a running microVM to a rootfs tar.
+"""FirecrackerFreezer — snapshot a running microVM to a Docker image.
 
 The VM is live and can't be block-copied safely, so — like the macOS
 backend — we stream the guest root filesystem out over the control
-channel (SSH here). Unlike the other backends this needs no Docker: the
+channel (SSH here) and rebuild an image from it. The bottle keeps
-tar *is* the resumable artifact. `resume` extracts it and rebuilds a
+running after the snapshot.
-fresh per-bottle ext4 with `mke2fs -d` (see `util.build_committed_rootfs_dir`
-and `launch._build_agent_base`). The bottle keeps running after the
-snapshot.
 """
 
 from __future__ import annotations
@@ -14,9 +11,9 @@ from __future__ import annotations
 import json
 import os
 import subprocess
+import tempfile
 from pathlib import Path
 
-from ...bottle_state import committed_rootfs_path
 from ...log import die, info
 from .. import ActiveAgent
 from ..freeze import Freezer
@@ -33,13 +30,14 @@ class FirecrackerFreezer(Freezer):
         if not private_key.is_file() or not guest_ip:
             die(f"cannot freeze {agent.slug}: run dir {run_dir} is missing the "
                 f"SSH key or VM config (is the bottle still running?)")
-        tar_path = committed_rootfs_path(agent.slug)
+        image_tag = f"bot-bottle-committed-{agent.slug}:latest"
-        _commit_rootfs_via_ssh(private_key, guest_ip, tar_path)
+        _commit_via_ssh(private_key, guest_ip, image_tag)
-        info(f"committed {agent.slug} -> {tar_path}")
+        info(f"committed {agent.slug} -> {image_tag!r}")
-        return str(tar_path)
+        return image_tag
 
     def _export_hint(self, slug: str, image_ref: str) -> None:
-        info(f"to export for migration:      cp {image_ref} {slug}.tar")
+        info(f"to export for migration:      docker image save {image_ref} "
+             f"-o {slug}.tar")
 
 
 def _guest_ip_from_config(config_path: Path) -> str:
@@ -55,27 +53,11 @@ def _guest_ip_from_config(config_path: Path) -> str:
     return ""
 
 
-def _commit_rootfs_via_ssh(private_key: Path, guest_ip: str, tar_path: Path) -> None:
+def _commit_via_ssh(private_key: Path, guest_ip: str, image_tag: str) -> None:
-    """Stream the guest rootfs out over SSH into `tar_path`. Excludes the
+    with tempfile.TemporaryDirectory(prefix="bot-bottle-fc-commit.") as tmp:
-    virtual/live mounts (proc/sys/dev/run) — resume recreates those empty
+        rootfs_tar = os.path.join(tmp, "rootfs.tar")
-    mount points. Written to a `.partial` sibling and renamed on success so
-    a failed freeze never leaves a truncated artifact in its place."""
-    tar_path.parent.mkdir(parents=True, exist_ok=True)
-    partial = tar_path.with_name(tar_path.name + ".partial")
         ssh = util.ssh_base_argv(private_key, guest_ip)
-    # The snapshot can contain the bottle's private workspace, so keep it
+        with open(rootfs_tar, "wb") as tar_out:
-    # owner-only (0600) for the whole stream. The `os.open` mode only applies
-    # on *creation*, so unlink any leftover partial (a prior interrupted run
-    # could have left it world-readable, or something could swap in a symlink
-    # at this predictable name) and exclusively recreate it — O_EXCL|O_NOFOLLOW
-    # — then fchmod immediately so umask can't loosen it. Re-assert after the
-    # rename too (os.replace carries the source mode, but be explicit).
-    partial.unlink(missing_ok=True)
-    fd = os.open(
-        partial, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600
-    )
-    os.fchmod(fd, 0o600)
-    with os.fdopen(fd, "wb") as tar_out:
             result = subprocess.run(
                 [*ssh, "--", "tar", "--create", "--one-file-system",
                  "--exclude=./proc", "--exclude=./sys", "--exclude=./dev",
@@ -83,8 +65,12 @@ def _commit_rootfs_via_ssh(private_key: Path, guest_ip: str, tar_path: Path) ->
                 stdout=tar_out, stderr=subprocess.PIPE, check=False,
             )
         if result.returncode != 0:
-        partial.unlink(missing_ok=True)
             die(f"ssh tar for {guest_ip} failed: "
                 f"{(result.stderr or b'').decode().strip() or '<no stderr>'}")
-    os.replace(partial, tar_path)
+        with open(os.path.join(tmp, "Dockerfile"), "w", encoding="utf-8") as f:
-    os.chmod(tar_path, 0o600)
+            f.write("FROM scratch\nADD rootfs.tar /\nUSER node\nWORKDIR /home/node\n")
+        build = subprocess.run(
+            ["docker", "build", "-t", image_tag, tmp], check=False,
+        )
+        if build.returncode != 0:
+            die(f"docker build for {image_tag!r} failed")

bot_bottle/backend/firecracker/image_builder.py

@@ -1,224 +0,0 @@
-"""Docker-free agent-image builds for the Firecracker backend (PRD 0069 Stage 3).
-
-Agent Dockerfiles build **inside the persistent per-host infra VM**
-(`infra_vm.py`), which carries buildah (rootless, daemonless): no host Docker
-daemon, no root-equivalent `docker` group. The build runs over SSH against the
-infra VM and its rootfs streams back to the host, where the existing
-`mke2fs -d` path (`util.build_rootfs_ext4`) turns it into a bootable ext4.
-
-Building in the infra VM — rather than a throwaway builder VM — means there is
-one buildah image (`bot-bottle-infra`) and no contention for the orchestrator
-TAP. Tradeoff: an untrusted Dockerfile's `RUN` steps share the VM with the
-control plane + gateway (buildah `--isolation chroot` isn't a hard boundary) —
-the accepted single-VM blast-radius tradeoff, re-splittable into a disposable
-builder (booted from this same image on its own TAP) later.
-"""
-
-from __future__ import annotations
-
-import fcntl
-import hashlib
-import os
-import shutil
-import subprocess
-from contextlib import contextmanager
-from pathlib import Path
-from typing import Generator
-
-from ...log import die, info
-from . import infra_vm, util
-
-# vfs + chroot: buildah works as root in the microVM (no fuse-overlayfs /
-# overlay module / subuid maps). `--isolation` is a build/run-only flag;
-# `from`/`mount` take just the store.
-_BUILD_FLAGS = "--isolation chroot --storage-driver vfs"
-_STORE_FLAG = "--storage-driver vfs"
-
-_BUILD_TIMEOUT_SECONDS = 900.0
-
-
-def _dockerfile_hash(dockerfile: Path) -> str:
-    """Cache key: the Dockerfile's content. The shipped agent Dockerfiles
-    COPY nothing from the build context (see .dockerignore), so their content
-    fully determines the image; a Dockerfile that adds COPY will want the
-    context folded in here too."""
-    return hashlib.sha256(dockerfile.read_bytes()).hexdigest()[:16]
-
-
-def build_agent_rootfs_dir(
-    dockerfile: Path, *, image_tag: str, smoke_test: tuple[str, ...] = (),
-) -> Path:
-    """Build `dockerfile` in the infra VM (buildah, no host docker), export its
-    rootfs, inject the guest boot bits, and return the cached base dir — the
-    same shape `util.build_rootfs_ext4` consumes. Cached by Dockerfile content,
-    so a repeat launch skips the rebuild.
-
-    `smoke_test` (the provider's declared argv, e.g. `("claude","--version")`)
-    is run in the freshly built image before export, catching an npm
-    silent-failure image at build time rather than at first agent use."""
-    digest = _dockerfile_hash(dockerfile)
-    base = util.cache_dir() / "rootfs" / f"agent-{digest}"
-    if (base / ".bb-ready").is_file():
-        info(f"using cached agent rootfs {base.name}")
-        return base
-
-    # Serialize builds: the infra VM's buildah store + this cache dir are
-    # shared, so concurrent `start`s must not build into them at once. The
-    # lock covers the cache lookup + build + atomic publish; the ready
-    # fast-path above takes no lock.
-    with _build_lock():
-        if (base / ".bb-ready").is_file():  # another build finished while we waited
-            info(f"using cached agent rootfs {base.name}")
-            return base
-        # Build into a temp dir and publish by atomic rename, so a partial
-        # build is never visible as `agent-<digest>`.
-        staging = util.cache_dir() / "rootfs" / f".building-{digest}"
-        shutil.rmtree(staging, ignore_errors=True)
-        staging.mkdir(parents=True)
-        info(f"building agent image {image_tag!r} in the infra VM")
-        _build_in_infra(dockerfile, staging, smoke_test, digest)
-        util.inject_guest_boot(staging)
-        (staging / ".bb-ready").write_text("ok\n")
-        shutil.rmtree(base, ignore_errors=True)
-        os.rename(staging, base)
-    return base
-
-
-@contextmanager
-def _build_lock() -> Generator[None, None, None]:
-    """Host-level exclusive lock serializing agent-image builds (shared infra
-    buildah store + cache dir). flock auto-releases on a crash."""
-    lock_path = util.cache_dir() / "rootfs" / ".build.lock"
-    lock_path.parent.mkdir(parents=True, exist_ok=True)
-    handle = open(lock_path, "w", encoding="utf-8")
-    try:
-        fcntl.flock(handle, fcntl.LOCK_EX)
-        yield
-    finally:
-        handle.close()
-
-
-def _build_in_infra(
-    dockerfile: Path, base: Path, smoke_test: tuple[str, ...], digest: str,
-) -> None:
-    """Ensure the infra VM is up, `buildah build` the Dockerfile in it, smoke
-    test the image, and stream its rootfs into `base`. The infra VM persists;
-    only the per-build container/image/context are cleaned up."""
-    infra = infra_vm.ensure_running()
-    key, ip = infra.private_key, infra.guest_ip
-    tag = f"bot-bottle-agent-build-{digest}"
-    ctx = f"/tmp/agent-build-{digest}"
-    smoke_ctr, export_ctr = f"{tag}-smoke", f"{tag}-export"
-
-    def _cleanup() -> None:
-        # Remove only THIS build's working containers/image/context — never
-        # `buildah rm -a`, which would nuke a concurrent build's container.
-        _ssh(key, ip,
-             f"buildah rm {smoke_ctr} {export_ctr} >/dev/null 2>&1; "
-             f"buildah rmi {_STORE_FLAG} {tag} >/dev/null 2>&1; rm -rf {ctx}",
-             timeout=60)
-
-    _cleanup()  # clear leftovers from a crashed prior build of this digest
-    try:
-        prep = _ssh(key, ip, f"mkdir -p {ctx}/ctx")
-        if prep.returncode != 0:
-            die(f"preparing build dir in the infra VM failed: {prep.stderr.strip()}")
-        _send_dockerfile(key, ip, dockerfile, ctx)
-        _buildah_build(key, ip, ctx, tag)
-        _smoke_test(key, ip, tag, smoke_ctr, smoke_test)
-        _stream_rootfs(key, ip, tag, export_ctr, base)
-    finally:
-        _cleanup()
-
-
-def _ssh(private_key: Path, guest_ip: str, script: str,
-         *, timeout: float = 60.0) -> subprocess.CompletedProcess[str]:
-    return subprocess.run(
-        util.ssh_base_argv(private_key, guest_ip) + [script],
-        capture_output=True, text=True, timeout=timeout, check=False,
-    )
-
-
-def _ssh_streamed(private_key: Path, guest_ip: str, script: str,
-                  *, timeout: float) -> int:
-    """Run an SSH command letting the remote's stdout/stderr flow straight to
-    ours (no capture), for long chatty steps where live progress beats a
-    silent wait. Returns the exit code."""
-    proc = subprocess.run(
-        util.ssh_base_argv(private_key, guest_ip) + [script],
-        timeout=timeout, check=False,
-    )
-    return proc.returncode
-
-
-def _send_dockerfile(private_key: Path, guest_ip: str, dockerfile: Path, ctx: str) -> None:
-    proc = subprocess.run(
-        util.ssh_base_argv(private_key, guest_ip) + [f"cat > {ctx}/Dockerfile"],
-        input=dockerfile.read_bytes(), capture_output=True, timeout=30, check=False,
-    )
-    if proc.returncode != 0:
-        die(f"sending Dockerfile to the infra VM failed: "
-            f"{proc.stderr.decode(errors='replace').strip()}")
-
-
-def _buildah_build(private_key: Path, guest_ip: str, ctx: str, tag: str) -> None:
-    # Stream buildah's step-by-step output straight to our stderr (like the
-    # docker backend's `docker build`), so a long first build (base pull +
-    # apt/npm installs) shows live progress instead of a silent wait. The
-    # remote stderr is where buildah writes its `STEP i/n` lines.
-    info(f"buildah build {tag} in the infra VM (streaming output)")
-    rc = _ssh_streamed(
-        private_key, guest_ip,
-        f"buildah build {_BUILD_FLAGS} -t {tag} -f {ctx}/Dockerfile {ctx}/ctx",
-        timeout=_BUILD_TIMEOUT_SECONDS,
-    )
-    if rc != 0:
-        die(f"buildah build in the infra VM failed (exit {rc}); "
-            "see the build output above.")
-
-
-def _smoke_test(private_key: Path, guest_ip: str, tag: str, ctr: str,
-                argv: tuple[str, ...]) -> None:
-    """Run the provider's smoke argv inside the freshly built image
-    (`buildah run`, which uses the image's own PATH), failing the build
-    loudly if the CLI is a broken stub. No-op without a declared test. Uses a
-    named working container (`ctr`) so cleanup is scoped to this build."""
-    if not argv:
-        return
-    cmd = (
-        f"set -e; buildah from {_STORE_FLAG} --name {ctr} {tag} >/dev/null; "
-        f"buildah run {_BUILD_FLAGS} {ctr} -- {' '.join(argv)}; rc=$?; "
-        f"buildah rm {ctr} >/dev/null 2>&1 || true; exit $rc"
-    )
-    result = _ssh(private_key, guest_ip, cmd, timeout=120)
-    if result.returncode != 0:
-        detail = (result.stdout + result.stderr).strip().splitlines()[-10:]
-        die(f"agent image failed its post-build smoke test "
-            f"({' '.join(argv)}):\n" + "\n".join(detail))
-
-
-def _stream_rootfs(private_key: Path, guest_ip: str, tag: str, ctr: str, base: Path) -> None:
-    """`buildah mount` the built image in the infra VM and pipe its rootfs tar
-    straight into `base` on the host (extracted as the non-root host user, so
-    uid 0 isn't preserved — the guest init restores /root ownership). Uses a
-    named working container so cleanup is scoped to this build."""
-    export = (
-        f"set -e; buildah from {_STORE_FLAG} --name {ctr} {tag} >/dev/null; "
-        f"mnt=$(buildah mount {_STORE_FLAG} {ctr}); "
-        f"tar -C \"$mnt\" -cf - ."
-    )
-    ssh_proc = subprocess.Popen(
-        util.ssh_base_argv(private_key, guest_ip) + [export],
-        stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-    )
-    assert ssh_proc.stdout is not None
-    untar = subprocess.run(
-        ["tar", "-x", "-C", str(base)], stdin=ssh_proc.stdout, check=False,
-    )
-    ssh_proc.stdout.close()
-    ssh_err = (ssh_proc.stderr.read().decode(errors="replace")
-               if ssh_proc.stderr else "")
-    rc = ssh_proc.wait()
-    if rc != 0 or untar.returncode != 0:
-        die(f"exporting the built rootfs from the infra VM failed: "
-            f"{ssh_err.strip() or '<no stderr>'}")

bot_bottle/backend/firecracker/infra_artifact.py

@@ -1,199 +0,0 @@
-"""Prebuilt infra-VM rootfs, pulled as an artifact (PRD 0069 Stage 2).
-
-The Firecracker infra VM boots a fixed rootfs (orchestrator control plane +
-gateway + buildah, control-plane init as PID 1) that does not vary per launch —
-the per-boot bits (authorized_keys, guest IP) ride the kernel cmdline, so one
-rootfs boots on any host. Instead of building that rootfs on the launch host
-with Docker, we build it **off-host** and publish it as a versioned, ready-to-
-boot ext4 (gzip-compressed) to a Gitea **generic package**; the launch host
-downloads + verifies + boots it. No Docker, no image tooling on the launch
-host — just an HTTP fetch and gunzip.
-
-  publish (off-host, see publish_infra.py):
-    docker build -> rootfs dir -> mke2fs -> gzip -> PUT generic package
-  pull (this module, launch host):
-    GET .../rootfs.ext4.gz (+ .sha256) -> verify -> gunzip -> boot
-
-The artifact **version** is a content hash of everything baked into the rootfs
-(the shipped bot_bottle package, the three Dockerfiles, and the init), so a
-launch host always pulls the artifact matching its code and a content change
-can't silently boot a stale rootfs. A checksum mismatch fails closed.
-
-Set `BOT_BOTTLE_INFRA_BUILD=local` to skip the pull and build the rootfs
-locally with Docker (dev iteration on the Dockerfiles) — see `infra_vm`.
-"""
-
-from __future__ import annotations
-
-import gzip
-import hashlib
-import os
-import shutil
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-from ...log import die, info
-from . import util
-
-# Bump if the on-disk artifact *format* changes (compression, layout) so a new
-# scheme can't collide with a cached/published artifact of the old one.
-_ARTIFACT_FORMAT = "1"
-
-_REPO_ROOT = Path(__file__).resolve().parents[3]
-_DOCKERFILES = ("Dockerfile.orchestrator", "Dockerfile.gateway", "Dockerfile.infra")
-
-_DEFAULT_BASE = "https://gitea.dideric.is"
-_DEFAULT_OWNER = "didericis"
-_PACKAGE = "bot-bottle-firecracker-infra"
-
-# Streaming copy chunk for the (hundreds-of-MB) download.
-_CHUNK = 1 << 20
-
-
-def local_build_requested() -> bool:
-    """True when the operator opted into the dev Docker-build path instead of
-    pulling the published artifact (`BOT_BOTTLE_INFRA_BUILD=local`)."""
-    return os.environ.get("BOT_BOTTLE_INFRA_BUILD", "").strip().lower() == "local"
-
-
-def infra_artifact_version(init_script: str, *, repo_root: Path = _REPO_ROOT) -> str:
-    """Content hash (16 hex) of everything baked into the infra rootfs: the
-    whole shipped `bot_bottle` package, the three fixed Dockerfiles, and the
-    guest init. Deterministic across the publish host and the launch host when
-    both run the same checkout, so the tag the launch host pulls is exactly the
-    tag publish produced.
-
-    The package is `COPY bot_bottle /app/bot_bottle`'d wholesale into the image,
-    so hash *every* regular file under it — not just `*.py`. Non-Python inputs
-    (e.g. `egress_entrypoint.sh`, `netpool.defaults.env`) are baked in too, and
-    a change to one must bump the version or a launch host could boot a stale
-    rootfs whose code differs from its checkout. `__pycache__`/`.pyc` are the
-    only exclusions — build artifacts, never copied."""
-    h = hashlib.sha256()
-    h.update(f"format={_ARTIFACT_FORMAT}\n".encode())
-    pkg = repo_root / "bot_bottle"
-    for path in sorted(pkg.rglob("*")):
-        if not path.is_file():
-            continue
-        if "__pycache__" in path.parts or path.suffix == ".pyc":
-            continue
-        h.update(str(path.relative_to(repo_root)).encode())
-        h.update(b"\0")
-        h.update(path.read_bytes())
-    for name in _DOCKERFILES:
-        h.update(name.encode())
-        h.update(b"\0")
-        h.update((repo_root / name).read_bytes())
-    h.update(b"init\0")
-    h.update(init_script.encode())
-    return h.hexdigest()[:16]
-
-
-def _config() -> tuple[str, str, str]:
-    """(base_url, owner, token) for the generic-package endpoint. Base + owner
-    are overridable for other deployments / mirrors; the token comes solely from
-    `BOT_BOTTLE_INFRA_ARTIFACT_TOKEN` (a dedicated package-scoped token, kept
-    separate from the general-purpose Gitea token) and is optional — a public
-    package needs none to pull."""
-    base = os.environ.get("BOT_BOTTLE_INFRA_ARTIFACT_BASE", _DEFAULT_BASE).rstrip("/")
-    owner = os.environ.get("BOT_BOTTLE_INFRA_ARTIFACT_OWNER", _DEFAULT_OWNER)
-    token = os.environ.get("BOT_BOTTLE_INFRA_ARTIFACT_TOKEN", "")
-    return base, owner, token
-
-
-def artifact_url(version: str, filename: str) -> str:
-    """The generic-package download URL for one file of this version's
-    artifact (`rootfs.ext4.gz` / `rootfs.ext4.gz.sha256`)."""
-    base, owner, _ = _config()
-    return f"{base}/api/packages/{owner}/generic/{_PACKAGE}/{version}/{filename}"
-
-
-_GZ_NAME = "rootfs.ext4.gz"
-_SHA_NAME = "rootfs.ext4.gz.sha256"
-
-
-def _cache_root(version: str) -> Path:
-    return util.cache_dir() / "infra-artifact" / version
-
-
-def _open(url: str) -> urllib.request.Request:
-    _, _, token = _config()
-    req = urllib.request.Request(url)
-    if token:
-        req.add_header("Authorization", f"token {token}")
-    return req
-
-
-def _download(url: str, dest: Path) -> None:
-    """Stream `url` to `dest` (atomic via a `.part` sibling)."""
-    tmp = dest.with_suffix(dest.suffix + ".part")
-    try:
-        with urllib.request.urlopen(_open(url)) as resp, open(tmp, "wb") as out:
-            shutil.copyfileobj(resp, out, _CHUNK)
-    except urllib.error.HTTPError as e:
-        tmp.unlink(missing_ok=True)
-        if e.code == 404:
-            die(
-                f"infra artifact not published for this code version.\n"
-                f"    missing: {url}\n"
-                f"    publish it from a build host (Docker):\n"
-                f"        python3 -m bot_bottle.backend.firecracker.publish_infra\n"
-                f"    or build the rootfs locally: BOT_BOTTLE_INFRA_BUILD=local"
-            )
-        die(f"downloading infra artifact failed (HTTP {e.code}): {url}")
-    except urllib.error.URLError as e:
-        tmp.unlink(missing_ok=True)
-        die(f"infra artifact registry unreachable: {url} ({e.reason})")
-    tmp.replace(dest)
-
-
-def _sha256_file(path: Path) -> str:
-    h = hashlib.sha256()
-    with open(path, "rb") as fh:
-        for chunk in iter(lambda: fh.read(_CHUNK), b""):
-            h.update(chunk)
-    return h.hexdigest()
-
-
-def ensure_artifact_gz(version: str) -> Path:
-    """The verified, cached `rootfs.ext4.gz` for `version` — downloading it (and
-    its `.sha256`) once, then reusing it. Fail-closed on a checksum mismatch:
-    the partial is removed and we die rather than boot an unverified rootfs."""
-    root = _cache_root(version)
-    root.mkdir(parents=True, exist_ok=True)
-    gz = root / _GZ_NAME
-    ok = root / ".verified"
-    if gz.is_file() and ok.is_file():
-        return gz
-
-    info(f"pulling infra rootfs artifact {_PACKAGE}/{version}")
-    _download(artifact_url(version, _GZ_NAME), gz)
-    sha = root / _SHA_NAME
-    _download(artifact_url(version, _SHA_NAME), sha)
-
-    expected = sha.read_text().split()[0].strip().lower()
-    actual = _sha256_file(gz)
-    if actual != expected:
-        gz.unlink(missing_ok=True)
-        sha.unlink(missing_ok=True)
-        die(
-            f"infra artifact checksum mismatch for {version}:\n"
-            f"    expected {expected}\n"
-            f"    actual   {actual}\n"
-            f"    refusing to boot an unverified rootfs."
-        )
-    ok.write_text("ok\n")
-    return gz
-
-
-def materialize_ext4(version: str, dest: Path) -> None:
-    """Ensure the verified artifact is cached, then gunzip it to `dest` — a
-    fresh, writable per-boot rootfs (the VM mutates it; the cached `.gz` stays
-    pristine). Atomic via a `.part` sibling."""
-    gz = ensure_artifact_gz(version)
-    tmp = dest.with_suffix(dest.suffix + ".part")
-    info(f"expanding infra rootfs -> {dest}")
-    with gzip.open(gz, "rb") as src, open(tmp, "wb") as out:
-        shutil.copyfileobj(src, out, _CHUNK)
-    tmp.replace(dest)

bot_bottle/backend/firecracker/infra_vm.py

@@ -1,440 +0,0 @@
-"""The per-host infra VM for the Firecracker backend (PRD 0070 Stage B).
-
-A single persistent microVM that runs the orchestrator **control plane** (and,
-in a following step, the gateway **data plane**) — the trusted per-host service
-the docker backend runs as containers. It boots on the NAT'd orchestrator link
-(`netpool.orch_slot()`): the host CLI reaches its control plane over HTTP at the
-guest IP, and agent VMs reach its gateway ports over VM-to-VM routing.
-
-Build-from-source (the default while the design churns): the rootfs is exported
-from the locally built orchestrator image, which bakes the stdlib-only
-control-plane source. A pull-from-registry mode (Gitea's OCI registry) becomes
-the default later.
-
-SSH is left enabled for debugging; the control plane is the load-bearing
-surface.
-"""
-
-from __future__ import annotations
-
-import fcntl
-import hashlib
-import os
-import shlex
-import signal
-import stat
-import subprocess
-import time
-import urllib.error
-import urllib.request
-from contextlib import contextmanager
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Generator
-
-from ...log import die, info
-from ..docker import util as docker_mod
-from ..docker.gateway_provision import GatewayProvisionError
-from . import firecracker_vm, infra_artifact, netpool, util
-
-# The single infra-VM image: gateway data plane + baked control-plane source
-# (Dockerfile.infra FROM the gateway image). Built from source by default;
-# a pull-from-registry mode lands later.
-_INFRA_IMAGE = "bot-bottle-infra:latest"
-_GATEWAY_IMAGE = "bot-bottle-gateway:latest"
-_ORCHESTRATOR_IMAGE = "bot-bottle-orchestrator:latest"
-_REPO_ROOT = Path(__file__).resolve().parents[3]
-
-CONTROL_PLANE_PORT = 8099
-# Gateway data-plane ports (agent-facing): egress proxy, supervise MCP,
-# git-http. Reached by agent VMs over VM-to-VM routing (added next).
-EGRESS_PORT = 9099
-SUPERVISE_PORT = 9100
-GIT_HTTP_PORT = 9420
-# mitmproxy writes its CA here a beat after start; agents install it to trust
-# the gateway's TLS interception.
-_GATEWAY_CA_PATH = "/home/mitmproxy/.mitmproxy/mitmproxy-ca-cert.pem"
-
-# The infra VM makes direct upstream connections (gateway egress, and buildah
-# during builds), and the kernel `ip=` cmdline sets no resolver. Public for
-# now; routing DNS through a filtered path is a later refinement.
-_INFRA_RESOLVER = "1.1.1.1"
-
-_HEALTH_TIMEOUT_SECONDS = 45.0
-_HEALTH_POLL_SECONDS = 0.5
-_CA_TIMEOUT_SECONDS = 30.0
-
-
-@dataclass
-class InfraVm:
-    """A handle to the per-host infra VM: its guest IP and the stable SSH key
-    used to fetch the gateway CA / provision git-gate. `vm` is the live VMM
-    handle when this process booted it, and None when adopting a singleton a
-    prior launcher started (teardown then goes through the PID file)."""
-
-    guest_ip: str
-    private_key: Path
-    vm: firecracker_vm.VmHandle | None = None
-
-    @property
-    def control_plane_url(self) -> str:
-        return f"http://{self.guest_ip}:{CONTROL_PLANE_PORT}"
-
-    def terminate(self) -> None:
-        """Stop the infra VM — via the live handle if we booted it, else the
-        PID file (adopting-process case)."""
-        if self.vm is not None:
-            self.vm.terminate()
-        else:
-            _kill_pidfile()
-        _pid_file().unlink(missing_ok=True)
-
-    def gateway_ca_pem(self, *, timeout: float = _CA_TIMEOUT_SECONDS) -> str:
-        """The gateway's mitmproxy CA (PEM) that agents install to trust its
-        TLS interception. Generated a moment after boot, so this polls over
-        SSH until it appears (mirrors DockerGateway.ca_cert_pem)."""
-        deadline = time.monotonic() + timeout
-        while True:
-            proc = subprocess.run(
-                util.ssh_base_argv(self.private_key, self.guest_ip)
-                + [f"cat {_GATEWAY_CA_PATH}"],
-                capture_output=True, text=True, timeout=15, check=False,
-            )
-            if proc.returncode == 0 and "BEGIN CERTIFICATE" in proc.stdout:
-                return proc.stdout
-            if time.monotonic() >= deadline:
-                die(f"gateway CA not available after {timeout:g}s: "
-                    f"{proc.stderr.strip() or 'empty'}")
-            time.sleep(_HEALTH_POLL_SECONDS)
-
-
-def ensure_built() -> None:
-    """Ensure the infra rootfs is available before boot.
-
-    Default (docker-free, PRD 0069 Stage 2): download + verify the prebuilt
-    rootfs artifact matching this code version (see `infra_artifact`); the
-    launch host needs no Docker. `BOT_BOTTLE_INFRA_BUILD=local` instead builds
-    the three fixed images from source with host Docker — the infra image
-    `COPY --from`s the orchestrator image and is `FROM` the gateway image, so
-    both must exist first — for iterating on the Dockerfiles."""
-    if infra_artifact.local_build_requested():
-        build_infra_images_with_docker()
-        return
-    infra_artifact.ensure_artifact_gz(
-        infra_artifact.infra_artifact_version(_infra_init()))
-
-
-def build_infra_images_with_docker() -> None:
-    """Build the three fixed images from source with host Docker: orchestrator,
-    gateway, then the combined infra image (`COPY --from` orchestrator, `FROM`
-    gateway). The launch host uses this only in `BOT_BOTTLE_INFRA_BUILD=local`
-    mode; `publish_infra` uses it off-host to produce the published artifact."""
-    docker_mod.build_image(
-        _ORCHESTRATOR_IMAGE, str(_REPO_ROOT), dockerfile="Dockerfile.orchestrator")
-    docker_mod.build_image(
-        _GATEWAY_IMAGE, str(_REPO_ROOT), dockerfile="Dockerfile.gateway")
-    docker_mod.build_image(
-        _INFRA_IMAGE, str(_REPO_ROOT), dockerfile="Dockerfile.infra")
-
-
-def build_infra_rootfs_dir() -> Path:
-    """The infra VM's base rootfs: the infra image prepared with the
-    control-plane + gateway init as PID 1. The init's content is folded into
-    the cache key so an init change rebuilds the rootfs (the base image digest
-    alone wouldn't catch it)."""
-    init = _infra_init()
-    tag = hashlib.sha256(init.encode()).hexdigest()[:8]
-    return util.build_base_rootfs_dir(
-        _INFRA_IMAGE, variant=f"-infra-{tag}", init_script=init,
-    )
-
-
-def ensure_running() -> InfraVm:
-    """Idempotent per-host singleton. Adopt the infra VM if its control plane
-    is already healthy (a prior launcher booted it — it outlives short-lived
-    `start` processes); otherwise clear any stale VM and boot a fresh one.
-    Returns a handle usable for CA fetch / git-gate provisioning.
-
-    Concurrency-safe: the cold stop/build/boot path is serialized by a host
-    flock, so two simultaneous first launches don't both boot on the same
-    rootfs/PID. The healthy fast-path takes no lock."""
-    slot = netpool.orch_slot()
-    url = f"http://{slot.guest_ip}:{CONTROL_PLANE_PORT}"
-    key = _infra_dir() / "id_ed25519"
-    if key.exists() and _health_ok(url):
-        info(f"adopting running infra VM at {url}")
-        return InfraVm(guest_ip=slot.guest_ip, private_key=key)
-
-    with _singleton_lock():
-        # Re-check under the lock: another launcher may have booted it while
-        # we waited for the lock (double-checked, so we adopt not re-boot).
-        if key.exists() and _health_ok(url):
-            info(f"adopting running infra VM at {url}")
-            return InfraVm(guest_ip=slot.guest_ip, private_key=key)
-        stop()  # clear a stale/hung VM holding the link before booting fresh
-        ensure_built()
-        infra = boot()
-        wait_for_health(infra)
-        return infra
-
-
-@contextmanager
-def _singleton_lock() -> Generator[None, None, None]:
-    """Host-level exclusive lock serializing the infra VM's cold create path
-    (`stop`/`ensure_built`/`boot`). flock auto-releases if the launcher
-    crashes, so the lock is never leaked."""
-    lock_path = _infra_dir() / "singleton.lock"
-    handle = open(lock_path, "w", encoding="utf-8")
-    try:
-        fcntl.flock(handle, fcntl.LOCK_EX)
-        yield
-    finally:
-        handle.close()
-
-
-def stop() -> None:
-    """Stop the infra VM singleton (idempotent — absent is success)."""
-    _kill_pidfile()
-    _pid_file().unlink(missing_ok=True)
-
-
-def boot() -> InfraVm:
-    """Boot the infra VM (detached, so it outlives the launcher) on the
-    orchestrator link, recording its PID. Prefer `ensure_running`."""
-    slot = netpool.orch_slot()
-    if not netpool.tap_present(slot.iface):
-        die(f"orchestrator link {slot.iface} not present.\n"
-            f"    ./cli.py backend setup --backend=firecracker")
-
-    run_dir = _infra_dir()
-    rootfs = run_dir / "rootfs.ext4"
-    if infra_artifact.local_build_requested():
-        util.build_rootfs_ext4(build_infra_rootfs_dir(), rootfs, slack_mib=8192)
-    else:
-        # Prebuilt artifact already carries the buildah build slack; expand it
-        # to a fresh writable rootfs for this boot.
-        infra_artifact.materialize_ext4(
-            infra_artifact.infra_artifact_version(_infra_init()), rootfs)
-    private_key, pubkey = _stable_keypair()
-
-    info(f"booting infra VM on {slot.iface} (guest {slot.guest_ip})")
-    vm = firecracker_vm.boot(
-        name="bot-bottle-infra", rootfs=rootfs, tap=slot.iface,
-        guest_ip=slot.guest_ip, host_ip=slot.host_ip, pubkey=pubkey,
-        run_dir=run_dir, mem_mib=4096, detached=True,
-        data_drive=_ensure_registry_volume(),
-    )
-    _pid_file().write_text(str(vm.process.pid))
-    return InfraVm(guest_ip=slot.guest_ip, private_key=private_key, vm=vm)
-
-
-def _infra_dir() -> Path:
-    d = util.cache_dir() / "infra"
-    d.mkdir(parents=True, exist_ok=True)
-    return d
-
-
-def _pid_file() -> Path:
-    return _infra_dir() / "vm.pid"
-
-
-# The registry "volume": a host-side ext4 file attached to the infra VM as a
-# second virtio-block device (guest /dev/vdb), mounted at the control plane's
-# DB dir. It outlives the ephemeral rootfs, so the bottle registry survives an
-# infra-VM restart — the firecracker analogue of a docker volume. It is a
-# plain ext4 file: `sudo mount -o loop <path>` on the host (with the VM
-# stopped) to inspect bot-bottle.db directly.
-_REGISTRY_SIZE = "512M"
-
-
-def registry_volume_path() -> Path:
-    return _infra_dir() / "registry.ext4"
-
-
-def _ensure_registry_volume() -> Path:
-    """Create the empty ext4 registry volume on first use; reuse it after."""
-    vol = registry_volume_path()
-    if vol.exists():
-        return vol
-    info(f"creating infra registry volume {vol} ({_REGISTRY_SIZE})")
-    proc = subprocess.run(
-        ["mke2fs", "-q", "-t", "ext4", "-F", str(vol), _REGISTRY_SIZE],
-        capture_output=True, text=True, check=False,
-    )
-    if proc.returncode != 0:
-        vol.unlink(missing_ok=True)
-        die(f"creating registry volume failed: {proc.stderr.strip()}")
-    return vol
-
-
-def _stable_keypair() -> tuple[Path, str]:
-    """The infra VM's SSH keypair — generated once and reused, so any later
-    launcher can SSH in (fetch CA / provision) even though a different process
-    booted the VM. The pubkey is re-injected on every boot via the cmdline."""
-    d = _infra_dir()
-    key, pub = d / "id_ed25519", d / "id_ed25519.pub"
-    if key.exists() and pub.exists():
-        return key, pub.read_text().strip()
-    key.unlink(missing_ok=True)
-    pub.unlink(missing_ok=True)
-    subprocess.run(
-        ["ssh-keygen", "-t", "ed25519", "-N", "", "-q", "-f", str(key),
-         "-C", "bot-bottle-infra"],
-        check=True,
-    )
-    return key, pub.read_text().strip()
-
-
-def _kill_pidfile() -> None:
-    """SIGTERM (then SIGKILL) the recorded infra VMM, if it's still ours.
-    Guards against a recycled PID by checking the process is firecracker."""
-    try:
-        pid = int(_pid_file().read_text().strip())
-    except (OSError, ValueError):
-        return
-    try:
-        comm = Path(f"/proc/{pid}/comm").read_text().strip()
-    except OSError:
-        return  # already gone
-    if comm != "firecracker":
-        return  # PID recycled by an unrelated process
-    try:
-        os.kill(pid, signal.SIGTERM)
-        for _ in range(50):
-            if not Path(f"/proc/{pid}").exists():
-                return
-            time.sleep(0.1)
-        os.kill(pid, signal.SIGKILL)
-    except OSError:
-        pass
-
-
-def _health_ok(url: str) -> bool:
-    try:
-        with urllib.request.urlopen(f"{url}/health", timeout=1.0) as resp:
-            return resp.status == 200
-    except (urllib.error.URLError, TimeoutError, OSError):
-        return False
-
-
-class SshGatewayTransport:
-    """`GatewayTransport` for the gateway running in the infra VM — the docker
-    exec/cp equivalents over SSH (dropbear + the stable infra key)."""
-
-    def __init__(self, private_key: Path, guest_ip: str) -> None:
-        self._key = private_key
-        self._ip = guest_ip
-
-    def exec(self, argv: list[str]) -> None:
-        proc = subprocess.run(
-            util.ssh_base_argv(self._key, self._ip) + [shlex.join(argv)],
-            capture_output=True, text=True, timeout=60, check=False,
-        )
-        if proc.returncode != 0:
-            raise GatewayProvisionError(
-                f"infra gateway exec {argv!r} failed: {proc.stderr.strip()}")
-
-    def cp_into(self, src: str, dest: str) -> None:
-        # Preserve the source mode (docker cp does): the access-hook is staged
-        # 0700 and git-http execs it directly — a plain `cat >` would land it
-        # 0644 and the exec fails with EACCES; keys stay 0600.
-        mode = stat.S_IMODE(os.stat(src).st_mode)
-        q = shlex.quote(dest)
-        proc = subprocess.run(
-            util.ssh_base_argv(self._key, self._ip)
-            + [f"cat > {q} && chmod {mode:o} {q}"],
-            input=Path(src).read_bytes(), capture_output=True, timeout=30, check=False,
-        )
-        if proc.returncode != 0:
-            raise GatewayProvisionError(
-                f"infra gateway cp {src} -> {dest} failed: "
-                f"{proc.stderr.decode(errors='replace').strip()}")
-
-
-def gateway_transport() -> SshGatewayTransport:
-    """git-gate provisioning transport for the gateway in the infra VM, built
-    from the stable key + the orchestrator link's guest IP. Needs no live VM
-    handle, so teardown can use it too."""
-    return SshGatewayTransport(
-        _infra_dir() / "id_ed25519", netpool.orch_slot().guest_ip)
-
-
-def wait_for_health(
-    infra: InfraVm, *, timeout: float = _HEALTH_TIMEOUT_SECONDS,
-) -> None:
-    """Poll the control plane's /health until it answers 200 or the deadline
-    passes. Dies (with the console tail) if the VMM exits early."""
-    url = f"{infra.control_plane_url}/health"
-    deadline = time.monotonic() + timeout
-    while time.monotonic() < deadline:
-        if infra.vm is not None and not infra.vm.is_alive():
-            die(f"infra VM exited during boot (rc={infra.vm.process.returncode}).\n"
-                f"{firecracker_vm._console_tail(infra.vm.console_log)}")
-        try:
-            with urllib.request.urlopen(url, timeout=1.0) as resp:
-                if resp.status == 200:
-                    info(f"infra control plane healthy at {infra.control_plane_url}")
-                    return
-        except (urllib.error.URLError, TimeoutError, OSError):
-            pass
-        time.sleep(_HEALTH_POLL_SECONDS)
-    tail = (firecracker_vm._console_tail(infra.vm.console_log)
-            if infra.vm is not None else "")
-    die(f"infra control plane at {url} did not become healthy within "
-        f"{timeout:.0f}s.\n{tail}")
-
-
-def _infra_init() -> str:
-    """PID-1 init for the infra VM: mount the pseudo-filesystems, wire a
-    resolver, start dropbear (debug SSH), then launch the control plane and
-    the gateway data plane (multi-tenant against the local control plane)."""
-    return f"""#!/bin/sh
-# bot-bottle Firecracker infra VM init (PID 1).
-mount -t proc proc /proc 2>/dev/null
-mount -t sysfs sys /sys 2>/dev/null
-mount -t devtmpfs dev /dev 2>/dev/null
-mkdir -p /dev/pts && mount -t devpts devpts /dev/pts 2>/dev/null
-mount -o remount,rw / 2>/dev/null
-
-# Export a real PATH: a bare-init shell resolves its own execs via a
-# built-in default path, but that isn't in the *environment*, so
-# gateway_init's subprocess daemons (spawned as `python3 ...`) would
-# inherit no PATH and fail to find python3. Export it for all children.
-export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
-
-# Direct upstream resolver (control-plane / gateway egress + buildah).
-printf 'nameserver {_INFRA_RESOLVER}\\n' > /etc/resolv.conf 2>/dev/null
-
-# Debug SSH: install the per-boot pubkey from the kernel cmdline.
-KEY=$(sed -n 's/.*bb_pubkey=\\([^ ]*\\).*/\\1/p' /proc/cmdline | base64 -d 2>/dev/null)
-if [ -n "$KEY" ]; then
-    mkdir -p /root/.ssh
-    printf '%s\\n' "$KEY" > /root/.ssh/authorized_keys
-    chmod 700 /root/.ssh && chmod 600 /root/.ssh/authorized_keys
-fi
-chown -R 0:0 /root 2>/dev/null || true
-mkdir -p /etc/dropbear /run /var/lib/bot-bottle
-
-# Persistent registry volume (second virtio-block device, /dev/vdb) mounted
-# at the control plane's DB dir, so bot-bottle.db survives infra-VM restarts.
-mount -t ext4 /dev/vdb /var/lib/bot-bottle 2>/dev/null || true
-
-/bb-dropbear -R -E -p 22 &
-
-# Control plane. Source is baked at /app; the package is stdlib-only.
-cd /app
-BOT_BOTTLE_ROOT=/var/lib/bot-bottle python3 -m bot_bottle.orchestrator \\
-    --host 0.0.0.0 --port {CONTROL_PLANE_PORT} --broker stub &
-
-# Gateway data plane, multi-tenant: each request resolves source-IP ->
-# policy against the local control plane. The VM backend reaches git over
-# git-http (9420), so the git:// daemon (git-gate, needs a per-bottle
-# entrypoint the consolidated model doesn't use) is left out.
-BOT_BOTTLE_GATEWAY_DAEMONS=egress,git-http,supervise \\
-BOT_BOTTLE_ORCHESTRATOR_URL=http://127.0.0.1:{CONTROL_PLANE_PORT} \\
-SUPERVISE_DB_PATH=/var/lib/bot-bottle/db/bot-bottle.db \\
-    python3 /app/gateway_init.py &
-
-# Reap as PID 1; children are backgrounded, so `wait` blocks.
-while : ; do wait ; done
-"""

bot_bottle/backend/firecracker/launch.py

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

bot_bottle/backend/firecracker/netpool.defaults.env

@@ -15,11 +15,3 @@ BOT_BOTTLE_FC_POOL_SIZE=8
 BOT_BOTTLE_FC_IP_BASE=10.243.0.0
 BOT_BOTTLE_FC_IFACE_PREFIX=bbfc
 BOT_BOTTLE_FC_NFT_TABLE=bot_bottle_fc
-# The orchestrator/gateway VM's own TAP — a dedicated link OUTSIDE the
-# bbfc* agent pool. Unlike agent VMs (which reach only their gateway),
-# the orchestrator is trusted infra that needs real NAT'd internet
-# egress: to FROM-pull + apt/npm during in-VM agent-image builds
-# (buildah) and to forward agent egress upstream (Stage B gateway). Its
-# /31 is the top of the IP_BASE /16 (host x.y.255.0, guest x.y.255.1),
-# clear of the pool near the bottom of the block.
-BOT_BOTTLE_FC_ORCH_IFACE=bborch0

bot_bottle/backend/firecracker/netpool.py

@@ -18,7 +18,7 @@ Topology (per slot i):
   * a /31 host<->guest link: host = base + 2i (the gateway the VM
     routes through), guest = base + 2i + 1 (the VM's address).
   * isolation via ``table inet bot_bottle_fc``: a VM reaches only its
-    own gateway (DNAT'd from the host TAP IP) and nothing else.
+    own sidecar (DNAT'd from the host TAP IP) and nothing else.
 
 The default IP block is ``10.243.0.0/16`` — an intentionally obscure
 corner of RFC-1918 private space. RFC-1918 is the range *designated*
@@ -79,12 +79,6 @@ def _cfg(key: str) -> str:
 IFACE_PREFIX = _cfg("BOT_BOTTLE_FC_IFACE_PREFIX")
 NFT_TABLE = _cfg("BOT_BOTTLE_FC_NFT_TABLE")
 
-# The orchestrator/gateway VM's dedicated TAP — outside the bbfc* agent
-# pool and, unlike it, NAT'd to the internet (see `orch_slot`). The
-# orchestrator is trusted infra: it builds agent images in-VM (buildah
-# needs to FROM-pull + apt/npm) and forwards agent egress upstream.
-ORCH_IFACE = _cfg("BOT_BOTTLE_FC_ORCH_IFACE")
-
 
 def pool_size() -> int:
     return int(_cfg("BOT_BOTTLE_FC_POOL_SIZE"))
@@ -94,10 +88,10 @@ def ip_base() -> str:
     return _cfg("BOT_BOTTLE_FC_IP_BASE")
 
 
-# Gateway ports the VM reaches at its host-side TAP IP. Kept in sync
+# Sidecar ports the VM reaches at its host-side TAP IP. Kept in sync
 # with the backend constants (egress 9099, supervise 9100, git-http
 # 9420); rendered into the setup output for operator visibility.
-GATEWAY_PORTS = (9099, 9100, 9420)
+SIDECAR_PORTS = (9099, 9100, 9420)
 
 
 @dataclass(frozen=True)
@@ -129,25 +123,6 @@ def all_slots() -> list[Slot]:
     return [slot(i) for i in range(pool_size())]
 
 
-def orch_slot() -> Slot:
-    """The orchestrator/gateway VM's dedicated link — its own TAP
-    (`ORCH_IFACE`) on a /31 at the TOP of the IP_BASE /16 (host
-    x.y.255.0, guest x.y.255.1), well clear of the agent pool near the
-    bottom of the block. Unlike a pool `Slot`, this link is NAT'd out to
-    the internet by the setup (the orchestrator is trusted infra), so it
-    is deliberately *not* one of the isolated `bbfc*` slots.
-
-    `index` is -1 (sentinel: not a pool index)."""
-    base16 = int(ipaddress.IPv4Address(ip_base())) & 0xFFFF0000
-    host = base16 + 0xFF00
-    return Slot(
-        index=-1,
-        iface=ORCH_IFACE,
-        host_ip=str(ipaddress.IPv4Address(host)),
-        guest_ip=str(ipaddress.IPv4Address(host + 1)),
-    )
-
-
 # --- fail-closed verification ---------------------------------------
 
 def _run_ok(argv: list[str]) -> bool:

bot_bottle/backend/firecracker/publish_infra.py

@@ -1,169 +0,0 @@
-"""Build the infra rootfs and publish it as a Gitea generic package.
-
-The off-host (build / CI) half of PRD 0069 Stage 2: this DOES use Docker, but
-never on the launch host. It runs the same pipeline the launch host used to run
-locally — `docker build` the three fixed images, export to a rootfs dir, inject
-the guest boot, `mke2fs` to an ext4 with the buildah build slack — then gzips
-the ext4 and PUTs it (plus a `.sha256`) to
-`…/api/packages/<owner>/generic/bot-bottle-firecracker-infra/<version>/`.
-
-The `<version>` is `infra_artifact.infra_artifact_version(...)`, the content
-hash of the rootfs inputs, so a launch host at the same code checkout resolves
-the exact artifact this produced.
-
-  python3 -m bot_bottle.backend.firecracker.publish_infra [--dry-run] [--force]
-
-Auth: a token with `write:package` on the target owner, from
-`BOT_BOTTLE_INFRA_ARTIFACT_TOKEN`.
-"""
-
-from __future__ import annotations
-
-import argparse
-import gzip
-import hashlib
-import shutil
-import sys
-import tempfile
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-from . import infra_artifact, infra_vm, util
-
-_CHUNK = 1 << 20
-
-# A human-readable description shipped alongside the artifact — generic packages
-# have no description field, so this file *is* the description on the package
-# page. Uploaded on every publish so it never goes stale.
-_ABOUT_NAME = "about.txt"
-_ABOUT_TEXT = (
-    "bot-bottle infra rootfs for the Firecracker backend (PRD 0069 Stage 2, "
-    "#348): the per-host infra VM (orchestrator control plane + gateway + "
-    "buildah). Prebuilt off-host, gzip ext4; the launch host downloads + "
-    "sha256-verifies + boots it, no host Docker. The version tag is a content "
-    "hash of the rootfs inputs. Files: rootfs.ext4.gz + rootfs.ext4.gz.sha256.\n"
-)
-
-
-def _gzip(src: Path, dest: Path) -> None:
-    with open(src, "rb") as fh, gzip.open(dest, "wb") as out:
-        shutil.copyfileobj(fh, out, _CHUNK)
-
-
-def _sha256(path: Path) -> str:
-    h = hashlib.sha256()
-    with open(path, "rb") as fh:
-        for chunk in iter(lambda: fh.read(_CHUNK), b""):
-            h.update(chunk)
-    return h.hexdigest()
-
-
-def _put(url: str, body: "bytes | Path", token: str) -> None:
-    """PUT `body` (raw bytes, or a Path streamed from disk) to `url`. The rootfs
-    is hundreds of MB, so it is passed as a Path and streamed — `urlopen` reads
-    the open file in blocks rather than materializing it in memory (with an
-    explicit Content-Length, which Gitea requires and which also stops urllib
-    from `len()`-ing a non-bytes body)."""
-    handle = None
-    if isinstance(body, Path):
-        length = body.stat().st_size
-        handle = open(body, "rb")
-        data: object = handle
-    else:
-        length = len(body)
-        data = body
-    req = urllib.request.Request(url, data=data, method="PUT")  # type: ignore[arg-type]
-    req.add_header("Content-Length", str(length))
-    if token:
-        req.add_header("Authorization", f"token {token}")
-    req.add_header("Content-Type", "application/octet-stream")
-    try:
-        with urllib.request.urlopen(req) as resp:
-            print(f"  uploaded {url} (HTTP {resp.status})")
-    except urllib.error.HTTPError as e:
-        if e.code == 409:
-            raise SystemExit(
-                f"artifact already published at {url} (HTTP 409); "
-                f"bump the code version or pass --force to overwrite"
-            )
-        raise SystemExit(f"upload failed (HTTP {e.code}): {url}\n{e.read().decode(errors='replace')}")
-    except urllib.error.URLError as e:
-        raise SystemExit(f"registry unreachable: {url} ({e.reason})")
-    finally:
-        if handle is not None:
-            handle.close()
-
-
-def _delete(url: str, token: str) -> None:
-    req = urllib.request.Request(url, method="DELETE")
-    if token:
-        req.add_header("Authorization", f"token {token}")
-    try:
-        with urllib.request.urlopen(req):
-            pass
-    except urllib.error.HTTPError as e:
-        if e.code != 404:
-            raise SystemExit(f"could not overwrite existing artifact (HTTP {e.code}): {url}")
-    except urllib.error.URLError as e:
-        raise SystemExit(f"registry unreachable: {url} ({e.reason})")
-
-
-def build_artifact(out_dir: Path) -> tuple[str, Path, Path]:
-    """Build the infra rootfs ext4, gzip it, and write the checksum. Returns
-    `(version, gz_path, sha_path)`. Uses host Docker (off-host / CI)."""
-    version = infra_artifact.infra_artifact_version(infra_vm._infra_init())
-    print(f"building infra rootfs artifact {version} (docker)")
-    infra_vm.build_infra_images_with_docker()
-    base = infra_vm.build_infra_rootfs_dir()
-
-    ext4 = out_dir / "rootfs.ext4"
-    util.build_rootfs_ext4(base, ext4, slack_mib=8192)
-    gz = out_dir / "rootfs.ext4.gz"
-    print("compressing rootfs")
-    _gzip(ext4, gz)
-    ext4.unlink(missing_ok=True)
-
-    sha = out_dir / "rootfs.ext4.gz.sha256"
-    digest = _sha256(gz)
-    sha.write_text(f"{digest}  rootfs.ext4.gz\n")
-    print(f"  {gz.name}: {gz.stat().st_size / 1e6:.0f} MB  sha256={digest}")
-    return version, gz, sha
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(
-        prog="publish_infra", description="Build + publish the infra rootfs artifact.")
-    parser.add_argument("--dry-run", action="store_true",
-                        help="build the artifact but do not upload")
-    parser.add_argument("--force", action="store_true",
-                        help="overwrite an already-published artifact of this version")
-    args = parser.parse_args(argv)
-
-    _, _, token = infra_artifact._config()
-    if not args.dry_run and not token:
-        raise SystemExit(
-            "no publish token: set BOT_BOTTLE_INFRA_ARTIFACT_TOKEN to a token "
-            "with write:package")
-
-    with tempfile.TemporaryDirectory(prefix="bb-publish-infra.") as tmp:
-        version, gz, sha = build_artifact(Path(tmp))
-        gz_url = infra_artifact.artifact_url(version, gz.name)
-        sha_url = infra_artifact.artifact_url(version, sha.name)
-        about_url = infra_artifact.artifact_url(version, _ABOUT_NAME)
-        if args.dry_run:
-            print(f"dry-run: would upload -> {gz_url}")
-            return 0
-        if args.force:
-            _delete(gz_url, token)
-            _delete(sha_url, token)
-            _delete(about_url, token)
-        _put(gz_url, gz, token)  # streamed from disk (hundreds of MB)
-        _put(sha_url, sha.read_bytes(), token)  # tiny, in-memory is fine
-        _put(about_url, _ABOUT_TEXT.encode(), token)  # package description
-    print(f"published infra rootfs {version}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

bot_bottle/backend/firecracker/util.py

@@ -14,7 +14,6 @@ and `./cli.py backend setup --backend=firecracker`.
 
 from __future__ import annotations
 
-import hashlib
 import os
 import platform
 import shutil
@@ -160,22 +159,15 @@ def docker_image_id(ref: str) -> str:
     return result.stdout.strip().replace("sha256:", "")[:16]
 
 
-def build_base_rootfs_dir(
+def build_base_rootfs_dir(image_ref: str) -> Path:
-    image_ref: str, *, variant: str = "", init_script: str | None = None,
+    """Export the agent image's filesystem and inject the guest init +
-) -> Path:
+    static dropbear. Cached by image digest — the per-bottle bits
-    """Export the image's filesystem and inject the guest init + static
-    dropbear. Cached by image digest — the per-bottle bits
     (authorized_keys, IP) are passed at boot via the kernel cmdline, so
     this tree carries nothing bottle-specific and is safely shared.
 
-    `variant` suffixes the cache key so the same image can be prepared
-    with a different `init_script` (e.g. the infra VM boots the same
-    orchestrator image as the builder but runs the control plane as
-    PID 1, not the SSH-only agent init) without a cache collision.
-
     Returns the prepared directory (read as the `mke2fs -d` source)."""
     digest = docker_image_id(image_ref)
-    base = cache_dir() / "rootfs" / f"{digest}{variant}"
+    base = cache_dir() / "rootfs" / digest
     ready = base / ".bb-ready"
     if ready.is_file():
         return base
@@ -208,85 +200,18 @@ def build_base_rootfs_dir(
             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False,
         )
 
-    inject_guest_boot(base, init_script=init_script)
+    _inject_guest_boot(base)
     ready.write_text("ok\n")
     return base
 
 
-def build_committed_rootfs_dir(tar_path: Path) -> Path:
+def _inject_guest_boot(rootfs: Path) -> None:
-    """Prepare a base rootfs dir from a frozen-bottle snapshot tar (the
+    """Drop the static dropbear and the PID-1 init into the rootfs."""
-    freeze/resume path — no Docker). Extracts the snapshot, recreates the
+    shutil.copy2(dropbear_path(), rootfs / "bb-dropbear")
-    virtual mount points the freezer excluded, and injects the guest init +
+    os.chmod(rootfs / "bb-dropbear", 0o755)
-    static dropbear, mirroring `build_base_rootfs_dir` but sourced from a tar
+    init = rootfs / "bb-init"
-    we control rather than a Docker image.
+    init.write_text(_GUEST_INIT)
-
+    os.chmod(init, 0o755)
-    Cached under the rootfs cache, keyed by the tar's size+mtime so a
-    re-freeze re-extracts but repeated resumes of the same snapshot don't.
-    Returns the prepared directory (read as the `mke2fs -d` source)."""
-    st = tar_path.stat()
-    fingerprint = hashlib.sha256(
-        f"{tar_path}:{st.st_size}:{st.st_mtime_ns}".encode()
-    ).hexdigest()[:16]
-    base = cache_dir() / "rootfs" / f"committed-{fingerprint}"
-    ready = base / ".bb-ready"
-    if ready.is_file():
-        return base
-
-    if base.exists():
-        shutil.rmtree(base, ignore_errors=True)
-    base.mkdir(parents=True)
-
-    info(f"extracting committed rootfs {tar_path} -> {base}")
-    result = subprocess.run(
-        ["tar", "-x", "-f", str(tar_path), "-C", str(base)],
-        capture_output=True, text=True, check=False,
-    )
-    if result.returncode != 0:
-        die(f"extracting committed rootfs {tar_path} failed: "
-            f"{result.stderr.strip() or '<no stderr>'}")
-
-    # The freezer excludes the live/virtual filesystems from the snapshot;
-    # recreate them as empty mount points so the guest init can mount
-    # proc/sys/dev and dropbear has a writable /run.
-    for mount_point in ("proc", "sys", "dev", "run"):
-        (base / mount_point).mkdir(mode=0o755, exist_ok=True)
-
-    inject_guest_boot(base)
-    ready.write_text("ok\n")
-    return base
-
-
-def inject_guest_boot(rootfs: Path, init_script: str | None = None) -> None:
-    """Drop the static dropbear and the PID-1 init into the rootfs.
-    `init_script` defaults to the SSH-only agent init; the infra VM
-    passes its own (control plane + gateway) init.
-
-    A committed snapshot is guest-controlled, so `bb-dropbear`/`bb-init`
-    may already exist as symlinks aimed at a host file (e.g. bb-init ->
-    ~/.bashrc). Replace whatever is there and create the files with
-    O_EXCL|O_NOFOLLOW so the write always lands a fresh regular file in
-    the staging tree and never follows a planted symlink out of it."""
-    _write_staged_file(rootfs / "bb-dropbear", dropbear_path().read_bytes())
-    _write_staged_file(rootfs / "bb-init", (init_script or _GUEST_INIT).encode())
-
-
-def _write_staged_file(path: Path, data: bytes) -> None:
-    """Write `data` to `path` (mode 0755) as a fresh regular file inside a
-    staging rootfs, replacing any pre-existing entry without following a
-    symlink at `path`. Fails closed on anything unexpected there."""
-    if path.is_symlink() or path.exists():
-        if path.is_dir() and not path.is_symlink():
-            shutil.rmtree(path)
-        else:
-            path.unlink()
-    fd = os.open(
-        path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o755
-    )
-    try:
-        os.write(fd, data)
-    finally:
-        os.close(fd)
-    os.chmod(path, 0o755)
 
 
 def build_rootfs_ext4(base_dir: Path, out_path: Path, *, slack_mib: int = 1024) -> None:

bot_bottle/backend/macos_container/__init__.py

@@ -2,7 +2,7 @@
 
 Selectable via `BOT_BOTTLE_BACKEND=macos-container`. This package owns
 the Apple `container` CLI integration; launch remains gated until the
-gateway network enforcement shape is implemented.
+sidecar network enforcement shape is implemented.
 """
 
 from .backend import MacosContainerBottleBackend

bot_bottle/backend/macos_container/cleanup.py

@@ -9,6 +9,7 @@ from . import util as container_mod
 from .bottle_cleanup_plan import MacosContainerBottleCleanupPlan
 
 _PREFIX = "bot-bottle-"
+_BUNDLE_PREFIX = "bot-bottle-sidecars-"
 
 
 def _list_prefixed_containers() -> list[str]:
@@ -23,7 +24,7 @@ def _list_prefixed_containers() -> list[str]:
         return []
     return sorted(
         name for name in (line.strip() for line in result.stdout.splitlines())
-        if name.startswith(_PREFIX)
+        if name.startswith(_PREFIX) or name.startswith(_BUNDLE_PREFIX)
     )
 
 

bot_bottle/backend/macos_container/egress_apply.py

@@ -1,23 +1,35 @@
-"""Host-side egress route-apply for the macos-container backend.
+"""Host-side egress apply for the macos-container backend.
 
-The per-bottle companion container this used to signal (`container kill
+Uses `container kill --signal HUP` (Apple Container framework) instead
---signal HUP <container>`) was removed in the companion-container removal (#385),
+of `docker kill` to signal the sidecar bundle.
-along with the disabled macOS launch path. Fails closed until the macOS
-backend grows the consolidated gateway.
 """
 
 from __future__ import annotations
 
+import os
+import subprocess
+
+from ...log import warn
 from ..egress_apply import EgressApplicator, EgressApplyError
+from .launch import sidecar_container_name
 
 
 class MacOSContainerEgressApplicator(EgressApplicator):
     def _signal_bundle_reload(self, slug: str) -> None:
-        del slug
+        container = sidecar_container_name(slug)
+        result = subprocess.run(
+            ["container", "kill", "--signal", "HUP", container],
+            capture_output=True, text=True, check=False, env=os.environ,
+        )
+        if result.returncode != 0:
+            last_error = (result.stderr or "").strip() or (result.stdout or "").strip()
+            warn(
+                f"egress: routes updated on disk for {slug}, but bundle reload failed: "
+                f"{last_error or 'container kill failed'}"
+            )
             raise EgressApplyError(
-            "live egress route-apply was removed with the per-bottle "
+                f"could not reload egress bundle {container}: "
-            "companion container (#385); the macos-container backend is "
+                f"{last_error or 'container kill failed'}"
-            "disabled until it uses the consolidated gateway."
             )
 
 

bot_bottle/backend/macos_container/enumerate.py

@@ -1,14 +1,40 @@
-"""Active-agent enumeration for the macOS Apple Container backend.
+"""Active-agent enumeration for the macOS Apple Container backend."""
-
-The backend is disabled during the companion-container removal (#385) — it can't
-launch bottles, so there are none to enumerate. Enumeration returns when
-the backend grows the consolidated gateway.
-"""
 
 from __future__ import annotations
 
+import subprocess
+
+from ...bottle_state import read_metadata
 from .. import ActiveAgent
 
+_PREFIX = "bot-bottle-"
+_SIDECAR_PREFIX = "bot-bottle-sidecars-"
+
 
 def enumerate_active() -> list[ActiveAgent]:
+    result = subprocess.run(
+        ["container", "list", "--quiet"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
         return []
+    out: list[ActiveAgent] = []
+    for name in sorted(line.strip() for line in result.stdout.splitlines()):
+        if not name.startswith(_PREFIX):
+            continue
+        if name.startswith(_SIDECAR_PREFIX):
+            continue
+        slug = name[len(_PREFIX):]
+        metadata = read_metadata(slug)
+        out.append(ActiveAgent(
+            backend_name="macos-container",
+            slug=slug,
+            agent_name=metadata.agent_name if metadata else "?",
+            started_at=metadata.started_at if metadata else "",
+            services=(),
+            label=metadata.label if metadata else "",
+            color=metadata.color if metadata else "",
+        ))
+    return out

bot_bottle/backend/macos_container/launch.py

@@ -1,39 +1,458 @@
-"""Launch flow for the macOS Apple Container backend — disabled (#385).
+"""Launch flow for the macOS Apple Container backend.
 
-This backend launched a per-bottle companion container (the egress /
+This backend keeps the explicit proxy-env enforcement model for v1:
-git-gate / supervise data plane) alongside the agent container, with the
+the agent container is attached only to a host-only Apple Container
-agent's proxy env pointed at the companion's host-only IP. That
+network, while the sidecar bundle is attached to a NAT network first
-per-bottle-companion architecture was removed in the companion-container removal;
+and the host-only network second. The sidecar's host-only IP is
-the macOS backend will be re-enabled once it grows the consolidated
+discovered from `container inspect` and stamped into the agent's
-per-host gateway the docker backend already uses.
+HTTP_PROXY / HTTPS_PROXY env vars.
-
-Until then, launching a macOS bottle fails closed. `prepare` / `status`
-/ cleanup still work.
 """
 
 from __future__ import annotations
 
-from contextlib import contextmanager
+import dataclasses
+import os
+import subprocess
+from contextlib import ExitStack, contextmanager
+from pathlib import Path
 from typing import Callable, Generator
 
-from ...log import die
+from ...bottle_state import (
+    egress_state_dir,
+    git_gate_state_dir,
+    read_committed_image,
+)
+from ...egress import (
+    EGRESS_ROUTES_IN_CONTAINER,
+    egress_agent_env_entries,
+    egress_resolve_token_values,
+    egress_sidecar_env_entries,
+)
+from ...git_gate import (
+    provision_git_gate_dynamic_keys,
+    revoke_git_gate_provisioned_keys,
+)
+from ...log import die, info, warn
+from ...supervise import DB_PATH_IN_CONTAINER, SUPERVISE_PORT
+from ...util import expand_tilde
+from ..docker.egress import EGRESS_CA_IN_CONTAINER, EGRESS_PORT
+from ..docker.git_gate import (
+    GIT_GATE_ACCESS_HOOK_IN_CONTAINER,
+    GIT_GATE_CREDS_DIR_IN_CONTAINER,
+    GIT_GATE_ENTRYPOINT_IN_CONTAINER,
+    GIT_GATE_HOOK_IN_CONTAINER,
+)
+from ..docker.sidecar_bundle import (
+    SIDECAR_BUNDLE_DOCKERFILE,
+    SIDECAR_BUNDLE_IMAGE,
+)
+from ..docker.egress import egress_tls_init
+from ..util import AGENT_CA_BUNDLE, AGENT_CA_PATH
+from . import util as container_mod
 from .bottle import MacosContainerBottle
 from .bottle_plan import MacosContainerBottlePlan
 
 
+_REPO_DIR = str(Path(__file__).resolve().parent.parent.parent.parent)
+_AGENT_SLEEP_SECONDS = "2147483647"
+_GIT_HTTP_PORT = 9420
+_GIT_GATE_READY_FILE = "/run/git-gate/ready"
+
+
+def internal_network_name(slug: str) -> str:
+    return f"bot-bottle-net-{slug}"
+
+
+def egress_network_name(slug: str) -> str:
+    return f"bot-bottle-egress-{slug}"
+
+
+def sidecar_container_name(slug: str) -> str:
+    return f"bot-bottle-sidecars-{slug}"
+
+
 @contextmanager
 def launch(
     plan: MacosContainerBottlePlan,
     *,
     provision: Callable[[MacosContainerBottlePlan, "MacosContainerBottle"], str | None],
 ) -> Generator[MacosContainerBottle, None, None]:
-    """Fail closed: the macOS backend is disabled until it grows the
+    """Build, run, provision, and yield an Apple Container bottle."""
-    consolidated per-host gateway (the companion-container path it used
+    stack = ExitStack()
-    was removed in #385)."""
+    bottle_for_revoke = plan.manifest.bottle
-    del plan, provision
+    git_gate_dir_for_revoke = git_gate_state_dir(plan.slug)
-    die(
+
-        "the macos-container backend is temporarily disabled during the "
+    def teardown() -> None:
-        "companion-container removal (#385); it will return once it uses "
+        teardown_exc: BaseException | None = None
-        "the consolidated gateway. Use --backend=docker for now."
+        try:
+            stack.close()
+        except BaseException as exc:  # noqa: W0718 - teardown must continue
+            teardown_exc = exc
+            warn(f"macos-container teardown failed: {exc!r}")
+        revoke_git_gate_provisioned_keys(bottle_for_revoke, git_gate_dir_for_revoke)
+        if teardown_exc is not None:
+            raise teardown_exc
+
+    try:
+        plan = _mint_certs(plan)
+        plan = _build_images(plan)
+
+        internal_network = internal_network_name(plan.slug)
+        egress_network = egress_network_name(plan.slug)
+        _create_networks(internal_network, egress_network, stack)
+
+        plan = _provision_git_gate_keys(plan)
+
+        sidecar_name = sidecar_container_name(plan.slug)
+        container_mod.force_remove_container(sidecar_name)
+        _start_sidecar_bundle(plan, sidecar_name, internal_network, egress_network)
+        stack.callback(container_mod.force_remove_container, sidecar_name)
+        _stage_git_gate(plan, sidecar_name)
+
+        sidecar_ip = container_mod.container_ipv4_on_network(
+            sidecar_name, internal_network,
         )
-    yield  # unreachable — `die` raises; keeps this a generator/contextmanager
+        plan = _stamp_agent_urls(plan, sidecar_ip)
+
+        container_mod.force_remove_container(plan.container_name)
+        _start_agent(plan, internal_network, sidecar_ip)
+        stack.callback(container_mod.force_remove_container, plan.container_name)
+
+        bottle = MacosContainerBottle(
+            plan.container_name,
+            teardown,
+            None,
+            agent_command=plan.agent_command,
+            agent_prompt_mode=plan.agent_prompt_mode,
+            agent_provider_template=plan.agent_provider_template,
+            terminal_title=f"{plan.spec.label} ({plan.spec.agent_name})" if plan.spec.label else plan.spec.agent_name,
+            terminal_color=plan.spec.color,
+            agent_workdir=plan.workspace_plan.workdir,
+        )
+        bottle.prompt_path = provision(plan, bottle)
+
+        yield bottle
+    finally:
+        teardown()
+
+
+def _mint_certs(plan: MacosContainerBottlePlan) -> MacosContainerBottlePlan:
+    egress_ca_host, egress_ca_cert_only = egress_tls_init(
+        egress_state_dir(plan.slug),
+    )
+    egress_plan = dataclasses.replace(
+        plan.egress_plan,
+        mitmproxy_ca_host_path=egress_ca_host,
+        mitmproxy_ca_cert_only_host_path=egress_ca_cert_only,
+    )
+    return dataclasses.replace(plan, egress_plan=egress_plan)
+
+
+def _build_images(plan: MacosContainerBottlePlan) -> MacosContainerBottlePlan:
+    container_mod.build_image(
+        SIDECAR_BUNDLE_IMAGE,
+        _REPO_DIR,
+        dockerfile=SIDECAR_BUNDLE_DOCKERFILE,
+    )
+    committed = read_committed_image(plan.slug)
+    if committed and container_mod.image_exists(committed):
+        info(f"using committed image {committed!r}")
+        return dataclasses.replace(
+            plan,
+            agent_provision=dataclasses.replace(
+                plan.agent_provision,
+                image=committed,
+            ),
+        )
+    container_mod.build_image(
+        plan.image,
+        _REPO_DIR,
+        dockerfile=plan.dockerfile_path,
+    )
+    return plan
+
+
+def _create_networks(
+    internal_network: str,
+    egress_network: str,
+    stack: ExitStack,
+) -> None:
+    container_mod.create_network(internal_network, internal=True)
+    stack.callback(container_mod.remove_network, internal_network)
+    container_mod.create_network(egress_network)
+    stack.callback(container_mod.remove_network, egress_network)
+
+
+def _start_sidecar_bundle(
+    plan: MacosContainerBottlePlan,
+    sidecar_name: str,
+    internal_network: str,
+    egress_network: str,
+) -> None:
+    argv = _sidecar_run_argv(plan, sidecar_name, internal_network, egress_network)
+    effective_env = {**dict(os.environ), **plan.agent_provision.provisioned_env}
+    token_values = egress_resolve_token_values(
+        plan.egress_plan.token_env_map, effective_env,
+    )
+    env = {**os.environ, **token_values}
+    info(f"container run sidecar bundle {sidecar_name}")
+    result = subprocess.run(
+        argv, capture_output=True, text=True, env=env, check=False,
+    )
+    if result.returncode != 0:
+        die(
+            f"container run for sidecar bundle {sidecar_name} failed: "
+            f"{(result.stderr or '').strip() or '<no stderr>'}"
+        )
+
+
+def _start_agent(
+    plan: MacosContainerBottlePlan,
+    internal_network: str,
+    sidecar_ip: str,
+) -> None:
+    argv = _agent_run_argv(plan, internal_network, sidecar_ip)
+    env = {
+        **os.environ,
+        **plan.forwarded_env,
+    }
+    info(f"container run agent {plan.container_name}")
+    result = subprocess.run(
+        argv, capture_output=True, text=True, env=env, check=False,
+    )
+    if result.returncode != 0:
+        die(
+            f"container run for agent {plan.container_name} failed: "
+            f"{(result.stderr or '').strip() or '<no stderr>'}"
+        )
+
+
+def _stamp_agent_urls(
+    plan: MacosContainerBottlePlan,
+    sidecar_ip: str,
+) -> MacosContainerBottlePlan:
+    proxy_url = f"http://{sidecar_ip}:{EGRESS_PORT}"
+    supervise_url = ""
+    if plan.supervise_plan is not None:
+        supervise_url = f"http://{sidecar_ip}:{SUPERVISE_PORT}/"
+    git_gate_url = ""
+    if plan.git_gate_plan.upstreams:
+        git_gate_url = f"http://{sidecar_ip}:{_GIT_HTTP_PORT}"
+    return dataclasses.replace(
+        plan,
+        agent_proxy_url=proxy_url,
+        agent_git_gate_url=git_gate_url,
+        agent_supervise_url=supervise_url,
+    )
+
+
+def _provision_git_gate_keys(
+    plan: MacosContainerBottlePlan,
+) -> MacosContainerBottlePlan:
+    if not plan.git_gate_plan.upstreams:
+        return plan
+    git_gate_plan = provision_git_gate_dynamic_keys(
+        plan.manifest.bottle,
+        plan.git_gate_plan,
+        git_gate_state_dir(plan.slug),
+    )
+    return dataclasses.replace(plan, git_gate_plan=git_gate_plan)
+
+
+def _stage_git_gate(plan: MacosContainerBottlePlan, sidecar_name: str) -> None:
+    gp = plan.git_gate_plan
+    if not gp.upstreams:
+        return
+
+    container_mod.exec_container(
+        sidecar_name,
+        [
+            "mkdir",
+            "-p",
+            str(Path(GIT_GATE_HOOK_IN_CONTAINER).parent),
+            GIT_GATE_CREDS_DIR_IN_CONTAINER,
+            "/git",
+            str(Path(_GIT_GATE_READY_FILE).parent),
+        ],
+    )
+
+    for host_path, container_path in _git_gate_files(plan):
+        container_mod.copy_into_container(
+            sidecar_name, host_path, container_path,
+        )
+
+    container_mod.exec_container(
+        sidecar_name,
+        [
+            "sh",
+            "-c",
+            "chmod 755 "
+            f"{GIT_GATE_ENTRYPOINT_IN_CONTAINER} "
+            f"{GIT_GATE_HOOK_IN_CONTAINER} "
+            f"{GIT_GATE_ACCESS_HOOK_IN_CONTAINER} && "
+            f"chmod 600 {GIT_GATE_CREDS_DIR_IN_CONTAINER}/* && "
+            f"touch {_GIT_GATE_READY_FILE}",
+        ],
+    )
+
+
+def _git_gate_files(
+    plan: MacosContainerBottlePlan,
+) -> tuple[tuple[str, str], ...]:
+    gp = plan.git_gate_plan
+    files: list[tuple[str, str]] = [
+        (str(gp.entrypoint_script), GIT_GATE_ENTRYPOINT_IN_CONTAINER),
+        (str(gp.hook_script), GIT_GATE_HOOK_IN_CONTAINER),
+        (str(gp.access_hook_script), GIT_GATE_ACCESS_HOOK_IN_CONTAINER),
+    ]
+    for upstream in gp.upstreams:
+        files.append((
+            expand_tilde(upstream.identity_file),
+            f"{GIT_GATE_CREDS_DIR_IN_CONTAINER}/{upstream.name}-key",
+        ))
+        if upstream.known_hosts_file:
+            files.append((
+                str(upstream.known_hosts_file),
+                f"{GIT_GATE_CREDS_DIR_IN_CONTAINER}/{upstream.name}-known_hosts",
+            ))
+    return tuple(files)
+
+
+def _sidecar_run_argv(
+    plan: MacosContainerBottlePlan,
+    sidecar_name: str,
+    internal_network: str,
+    egress_network: str,
+) -> list[str]:
+    argv = [
+        "container", "run",
+        "--name", sidecar_name,
+        "--detach",
+        "--rm",
+        "--network", egress_network,
+        "--network", internal_network,
+        "--dns", _sidecar_dns(),
+        "--env", f"BOT_BOTTLE_SIDECAR_DAEMONS={','.join(_sidecar_daemons(plan))}",
+    ]
+    for entry in _sidecar_env_entries(plan):
+        argv += ["--env", entry]
+    for host_path, container_path, read_only in _sidecar_mounts(plan):
+        argv += ["--mount", _mount_spec(host_path, container_path, read_only)]
+    argv.append(SIDECAR_BUNDLE_IMAGE)
+    return argv
+
+
+def _agent_run_argv(
+    plan: MacosContainerBottlePlan,
+    internal_network: str,
+    sidecar_ip: str,
+) -> list[str]:
+    argv = [
+        "container", "run",
+        "--name", plan.container_name,
+        "--detach",
+        "--network", internal_network,
+    ]
+    for entry in _agent_env_entries(plan, sidecar_ip):
+        argv += ["--env", entry]
+    argv += [plan.image, "sleep", _AGENT_SLEEP_SECONDS]
+    return argv
+
+
+def _sidecar_dns() -> str:
+    return container_mod.dns_server()
+
+
+def _sidecar_daemons(plan: MacosContainerBottlePlan) -> tuple[str, ...]:
+    daemons = ["egress"]
+    if plan.git_gate_plan.upstreams:
+        daemons += ["git-gate", "git-http"]
+    if plan.supervise_plan is not None:
+        daemons.append("supervise")
+    return tuple(daemons)
+
+
+def _sidecar_env_entries(plan: MacosContainerBottlePlan) -> tuple[str, ...]:
+    env: list[str] = list(egress_sidecar_env_entries(plan.egress_plan))
+    if plan.git_gate_plan.upstreams:
+        env.append(f"BOT_BOTTLE_GIT_GATE_READY_FILE={_GIT_GATE_READY_FILE}")
+    if plan.supervise_plan is not None:
+        env += [
+            f"SUPERVISE_BOTTLE_SLUG={plan.slug}",
+            f"SUPERVISE_DB_PATH={DB_PATH_IN_CONTAINER}",
+            f"SUPERVISE_PORT={SUPERVISE_PORT}",
+        ]
+    return tuple(env)
+
+
+def _sidecar_mounts(
+    plan: MacosContainerBottlePlan,
+) -> tuple[tuple[str, str, bool], ...]:
+    mounts: list[tuple[str, str, bool]] = []
+
+    ep = plan.egress_plan
+    mounts.append((
+        str(ep.mitmproxy_ca_host_path.parent),
+        str(Path(EGRESS_CA_IN_CONTAINER).parent),
+        False,
+    ))
+    if ep.routes:
+        mounts.append((
+            str(ep.routes_path.parent),
+            str(Path(EGRESS_ROUTES_IN_CONTAINER).parent),
+            True,
+        ))
+
+    sp = plan.supervise_plan
+    if sp is not None:
+        # `container run --mount type=bind` only accepts directory
+        # sources (a file source fails with "is not a directory") —
+        # mount db_path's dedicated parent dir instead of the file
+        # itself, same as the CA/routes mounts above.
+        mounts.append((
+            str(sp.db_path.parent),
+            str(Path(DB_PATH_IN_CONTAINER).parent),
+            False,
+        ))
+
+    return tuple(mounts)
+
+def _mount_spec(host_path: str, container_path: str, read_only: bool) -> str:
+    spec = f"type=bind,source={host_path},target={container_path}"
+    if read_only:
+        spec += ",readonly"
+    return spec
+
+
+def _agent_env_entries(
+    plan: MacosContainerBottlePlan,
+    sidecar_ip: str,
+) -> tuple[str, ...]:
+    proxy_url = f"http://{sidecar_ip}:{EGRESS_PORT}"
+    no_proxy = _agent_no_proxy(plan, sidecar_ip)
+    env = [
+        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}",
+    ]
+    if plan.agent_git_gate_url:
+        env.append(f"GIT_GATE_URL={plan.agent_git_gate_url}")
+    if plan.agent_supervise_url:
+        env.append(f"MCP_SUPERVISE_URL={plan.agent_supervise_url}")
+    for name, value in sorted(plan.agent_provision.guest_env.items()):
+        env.append(f"{name}={value}")
+    for name in sorted(plan.forwarded_env.keys()):
+        env.append(name)
+    env.extend(egress_agent_env_entries(plan.egress_plan))
+    return tuple(env)
+
+
+def _agent_no_proxy(plan: MacosContainerBottlePlan, sidecar_ip: str) -> str:
+    hosts = ["localhost", "127.0.0.1", sidecar_ip]
+    return ",".join(hosts)

bot_bottle/backend/macos_container/util.py

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

bot_bottle/backend/resolve_common.py

@@ -94,7 +94,7 @@ def prepare_egress(
 
 
 def prepare_supervise(bottle: ManifestBottle, slug: str) -> SupervisePlan | None:
-    """Prepare the supervise daemon state dir. Returns None when
+    """Prepare the supervise sidecar state dir. Returns None when
     bottle.supervise is falsy."""
     if not bottle.supervise:
         return None

bot_bottle/bottle_state.py

@@ -31,7 +31,6 @@ from __future__ import annotations
 import dataclasses
 import json
 import secrets
-import socket
 import string
 from dataclasses import dataclass
 from pathlib import Path
@@ -44,18 +43,17 @@ from .paths import bot_bottle_root
 _STATE_SUBDIR = "state"
 _PER_BOTTLE_DOCKERFILE_NAME = "Dockerfile"
 _COMMITTED_IMAGE_NAME = "committed-image"
-_COMMITTED_ROOTFS_NAME = "committed-rootfs.tar"
 _TRANSCRIPT_SUBDIR = "transcript"
-# Per-daemon scratch subdirs. PRD 0018 chunk 2: bind-mount sources
+# Per-sidecar scratch subdirs. PRD 0018 chunk 2: bind-mount sources
 # live here so chunk 3's `docker compose up` can find them at stable
-# paths. Each daemon's `prepare()` writes config + CAs into its own
+# paths. Each sidecar's `prepare()` writes config + CAs into its own
 # subdir; the launch step is unchanged today (still `docker cp`).
 _EGRESS_SUBDIR = "egress"
 _GIT_GATE_SUBDIR = "git-gate"
 _SUPERVISE_SUBDIR = "supervise"
 _AGENT_SUBDIR = "agent"
 _METADATA_NAME = "metadata.json"
-# Live-config dir bind-mounted into the supervise daemon (read-only).
+# Live-config dir bind-mounted into the supervise sidecar (read-only).
 # Host's apply paths keep these files fresh so supervise's
 # `list-egress-routes` MCP tool returns the current state —
 # not a snapshot from launch time.
@@ -89,14 +87,6 @@ def bottle_identity(agent_name: str) -> str:
     return f"{slug}-{suffix}"
 
 
-def globalize_slug(slug: str) -> str:
-    """Return a globally-unique slug qualified with the current hostname.
-
-    Assumes slug is a value returned from mint_slug. Use wherever a slug
-    must be unique across hosts (e.g. deploy-key titles)."""
-    return f"{socket.gethostname()}-{slug}"
-
-
 @dataclass(frozen=True)
 class BottleMetadata:
     """Persistent record of how a bottle was launched, written at
@@ -201,15 +191,6 @@ def committed_image_path(identity: str) -> Path:
     return bottle_state_dir(identity) / _COMMITTED_IMAGE_NAME
 
 
-def committed_rootfs_path(identity: str) -> Path:
-    """Where the Firecracker freezer stores a snapshot of the bottle's
-    guest rootfs (a plain tar). This is the resumable/migratable artifact
-    the Firecracker backend boots from — no Docker image involved. The
-    matching `committed-image` state file records that a snapshot exists
-    (and its path); `resume` boots from this tar when both are present."""
-    return bottle_state_dir(identity) / _COMMITTED_ROOTFS_NAME
-
-
 def write_committed_image(identity: str, image_tag: str) -> Path:
     """Persist the committed image tag for `identity`. The next
     `cli.py resume <identity>` will boot from this image instead of
@@ -241,7 +222,7 @@ def per_bottle_image_tag(identity: str) -> str:
 
 def live_config_dir(identity: str) -> Path:
     """Per-bottle live-config dir. Bind-mounted read-only into the
-    supervise daemon; the host's apply paths refresh the files on
+    supervise sidecar; the host's apply paths refresh the files on
     every operator approval so the agent's `list-*` MCP tools always
     return current state."""
     return bottle_state_dir(identity) / _LIVE_CONFIG_SUBDIR
@@ -279,9 +260,9 @@ def transcript_snapshot_dir(identity: str) -> Path:
     return bottle_state_dir(identity) / _TRANSCRIPT_SUBDIR
 
 
-# --- Per-daemon scratch subdirs (PRD 0018 chunk 2) ------------------------
+# --- Per-sidecar scratch subdirs (PRD 0018 chunk 2) ------------------------
 #
-# Each daemon gets its own subdir under the bottle's state dir for
+# Each sidecar gets its own subdir under the bottle's state dir for
 # bind-mount sources (config, CAs, hooks, etc.). Prepare-time writes
 # land here; the state dir's normal cleanup (`cleanup_state`) reaps
 # them along with everything else when the bottle session ends and
@@ -289,20 +270,20 @@ def transcript_snapshot_dir(identity: str) -> Path:
 
 
 def egress_state_dir(identity: str) -> Path:
-    """State subdir for the egress daemon: routes.yaml + the
+    """State subdir for the egress sidecar: routes.yaml + the
     per-bottle mitmproxy CA. Bind-mount source from chunk 3 onward."""
     return bottle_state_dir(identity) / _EGRESS_SUBDIR
 
 
 def git_gate_state_dir(identity: str) -> Path:
-    """State subdir for the git-gate daemon: entrypoint + hooks +
+    """State subdir for the git-gate sidecar: entrypoint + hooks +
     per-upstream known_hosts. Bind-mount source from chunk 3
     onward."""
     return bottle_state_dir(identity) / _GIT_GATE_SUBDIR
 
 
 def supervise_state_dir(identity: str) -> Path:
-    """State subdir reserved for supervise daemon bind-mount sources.
+    """State subdir reserved for supervise sidecar bind-mount sources.
     Runtime queue/audit rows live in the host-level bot-bottle SQLite
     database, so they survive state-dir cleanup."""
     return bottle_state_dir(identity) / _SUPERVISE_SUBDIR
@@ -359,12 +340,10 @@ __all__ = [
     "BottleMetadata",
     "agent_state_dir",
     "bottle_identity",
-    "globalize_slug",
     "bottle_state_dir",
     "cleanup_state",
     "clear_preserve_marker",
     "committed_image_path",
-    "committed_rootfs_path",
     "egress_state_dir",
     "git_gate_state_dir",
     "is_preserved",

bot_bottle/cli/cleanup.py

@@ -2,8 +2,8 @@
 
 Walks every registered backend (docker, firecracker, macos-container)
 so a single `./cli.py cleanup` reaps every backend's leftovers — a
-firecracker bottle's VM processes and run dirs won't survive a
+firecracker bottle's sidecars won't survive a docker-only cleanup pass
-docker-only cleanup pass (issue addressed alongside #77).
+(issue addressed alongside #77).
 
 Each backend's `prepare_cleanup` enumerates its own resources;
 docker's `_list_orphan_state_dirs` consults

bot_bottle/cli/start.py

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

bot_bottle/cli/supervise.py

@@ -20,19 +20,32 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from ..paths import bot_bottle_root
-from ..log import Die, error, info
+from ..bottle_state import read_metadata
-from ..orchestrator.client import (
+from ..backend.docker.egress_apply import (
-    OrchestratorClient,
+    EgressApplyError,
-    OrchestratorClientError,
+    applicator as _docker_applicator,
-    discover_orchestrator_url,
 )
+from ..backend.macos_container.egress_apply import (
+    applicator as _macos_applicator,
+)
+from ..log import Die, error, info
 
 from ..supervise import (
+    COMPONENT_FOR_TOOL,
+    AuditEntry,
     Proposal,
+    Response,
+    STATUS_APPROVED,
+    STATUS_MODIFIED,
+    STATUS_REJECTED,
     TOOL_EGRESS_ALLOW,
     TOOL_EGRESS_BLOCK,
     TOOL_GITLEAKS_ALLOW,
     TOOL_EGRESS_TOKEN_ALLOW,
+    list_all_pending_proposals,
+    render_diff,
+    write_audit_entry,
+    write_response,
 )
 from ._common import PROG
 
@@ -47,61 +60,30 @@ _REPORT_ONLY_TOOLS: tuple[str, ...] = (TOOL_GITLEAKS_ALLOW, TOOL_EGRESS_TOKEN_AL
 
 @dataclass(frozen=True)
 class QueuedProposal:
-    """A pending proposal from the supervise queue.
+    """A pending proposal from the supervise queue."""
-
-    `label` is the operator-facing bottle name (the human slug the
-    orchestrator resolved from the registry); `proposal.bottle_slug` is the
-    opaque bottle_id every operator action is keyed by. Display uses `label`;
-    respond calls use `proposal.bottle_slug`."""
 
     proposal: Proposal
-    label: str = ""
 
 
-# A failed operator action (orchestrator unreachable, bottle torn down,
+# Errors any remediation engine may raise. Caught by the TUI key
-# 409) is caught by the TUI key handlers and surfaced in the status line so
+# handlers and surfaced in the status line so a failed apply keeps
-# the proposal stays pending rather than crashing curses.
+# the proposal pending rather than crashing curses.
-ApplyError = (OrchestratorClientError,)
+ApplyError = (EgressApplyError,)
 
 
-# The one per-host orchestrator, discovered lazily on first use. Every
+def apply_routes_change(slug: str, content: str) -> tuple[str, str]:
-# operator action — list, approve, reject — goes through its HTTP control
+    meta = read_metadata(slug)
-# plane (the orchestrator owns the single DB + live policy); there is no
+    backend = meta.backend if meta is not None else ""
-# direct-DB path and no backend branching here.
+    if backend == "macos-container":
-_client_instance: OrchestratorClient | None = None
+        return _macos_applicator.apply_routes_change(slug, content)
-
+    return _docker_applicator.apply_routes_change(slug, content)
-
-def _resolve_orchestrator_url() -> str:
-    """URL of the running orchestrator control plane, starting one on demand.
-
-    Supervise is often the first thing an operator runs — before any bottle
-    has booted the control plane. So when discovery finds nothing, bring up
-    the selected backend's orchestrator + gateway (idempotent) rather than
-    failing with "launch a bottle first"."""
-    try:
-        return discover_orchestrator_url()
-    except OrchestratorClientError:
-        from ..backend import get_bottle_backend
-        backend = get_bottle_backend()
-        info(f"no orchestrator control plane running; starting one ({backend.name})…")
-        return backend.ensure_orchestrator()
-
-
-def _client() -> OrchestratorClient:
-    global _client_instance  # noqa: PLW0603 — CLI-session singleton
-    if _client_instance is None:
-        _client_instance = OrchestratorClient(_resolve_orchestrator_url())
-    return _client_instance
 
 
 def discover_pending() -> list[QueuedProposal]:
-    """Collect pending proposals across bottles from the orchestrator."""
+    """Collect pending proposals across bottles."""
     out = [
-        QueuedProposal(
+        QueuedProposal(proposal=proposal)
-            proposal=Proposal.from_dict(d),
+        for proposal in list_all_pending_proposals()
-            label=str(d.get("bottle_label") or d.get("bottle_slug") or ""),
-        )
-        for d in _client().supervise_pending()
     ]
     out.sort(key=lambda q: q.proposal.arrival_timestamp)
     return out
@@ -109,8 +91,8 @@ def discover_pending() -> list[QueuedProposal]:
 
 def _approval_status(qp: QueuedProposal, verb: str) -> str:
     """Status-line text after a successful approval."""
-    base = f"{verb} {qp.proposal.tool} for [{qp.label}]"
+    base = f"{verb} {qp.proposal.tool} for [{qp.proposal.bottle_slug}]"
-    return f"{base}; resume: ./cli.py resume {qp.label}"
+    return f"{base}; resume: ./cli.py resume {qp.proposal.bottle_slug}"
 
 
 def _detail_lines(
@@ -121,7 +103,7 @@ def _detail_lines(
     """Return the detail-view body as (text, curses-attr) tuples."""
     p = qp.proposal
     out: list[tuple[str, int]] = [
-        (f"bottle: {qp.label}", 0),
+        (f"bottle: {p.bottle_slug}", 0),
         (f"tool: {p.tool}", 0),
         (f"id: {p.id}", 0),
         (f"arrived: {p.arrival_timestamp}", 0),
@@ -154,27 +136,39 @@ def approve(
     notes: str = "",
     final_file: str | None = None,
 ) -> None:
-    """Approve (or, with `final_file`, modify-then-approve) via the
+    """Apply the proposal, write the waiting response, and audit it."""
-    orchestrator: it applies the route change to the bottle's live policy,
+    status = STATUS_MODIFIED if final_file is not None else STATUS_APPROVED
-    writes the response that unblocks the agent, and audits it — one atomic
+    file_to_apply = final_file if final_file is not None else qp.proposal.proposed_file
-    server-side op. Raises `OrchestratorClientError` on failure."""
+
-    _client().supervise_respond(
+    diff_before, diff_after = "", ""
-        qp.proposal.id,
+    if qp.proposal.tool in (TOOL_EGRESS_ALLOW, TOOL_EGRESS_BLOCK):
-        bottle_slug=qp.proposal.bottle_slug,
+        diff_before, diff_after = apply_routes_change(
-        decision="modify" if final_file is not None else "approve",
+            qp.proposal.bottle_slug,
+            file_to_apply,
+        )
+
+    response = Response(
+        proposal_id=qp.proposal.id,
+        status=status,
         notes=notes,
         final_file=final_file,
     )
-
+    write_response(qp.proposal.bottle_slug, response)
+    _write_audit(
+        qp, action=status, notes=notes,
+        diff_before=diff_before, diff_after=diff_after,
+    )
 
 def reject(qp: QueuedProposal, *, reason: str) -> None:
-    """Reject via the orchestrator (writes the response + audit)."""
+    """Write a rejection response and an audit entry."""
-    _client().supervise_respond(
+    response = Response(
-        qp.proposal.id,
+        proposal_id=qp.proposal.id,
-        bottle_slug=qp.proposal.bottle_slug,
+        status=STATUS_REJECTED,
-        decision="reject",
         notes=reason,
+        final_file=None,
     )
+    write_response(qp.proposal.bottle_slug, response)
+    _write_audit(qp, action=STATUS_REJECTED, notes=reason, diff_before="", diff_after="")
 
 
 def _approve_from_tui(
@@ -194,6 +188,29 @@ def _approve_from_tui(
     return _approval_status(qp, verb)
 
 
+def _write_audit(
+    qp: QueuedProposal,
+    *,
+    action: str,
+    notes: str,
+    diff_before: str,
+    diff_after: str,
+) -> None:
+    """Audit log for egress tool."""
+    component = COMPONENT_FOR_TOOL.get(qp.proposal.tool)
+    if component is None:
+        return
+    write_audit_entry(AuditEntry(
+        timestamp=datetime.now(timezone.utc).isoformat(),
+        bottle_slug=qp.proposal.bottle_slug,
+        component=component,
+        operator_action=action,
+        operator_notes=notes,
+        justification=qp.proposal.justification,
+        diff=render_diff(diff_before, diff_after, label=component),
+    ))
+
+
 # --- $EDITOR integration --------------------------------------------------
 
 
@@ -228,20 +245,6 @@ def cmd_supervise(argv: list[str]) -> int:
     )
     args = parser.parse_args(argv)
 
-    # Establish the orchestrator connection up front so a missing control
-    # plane is a clean one-line error, not a curses crash mid-loop. This also
-    # starts the orchestrator on demand when none is running (see `_client`).
-    try:
-        _client()
-    except OrchestratorClientError as e:
-        error(str(e))
-        return 1
-    except Die as e:
-        # Backend has no orchestrator to start (e.g. macos-container).
-        if e.message:
-            error(e.message)
-        return e.code if isinstance(e.code, int) else 1
-
     if args.once:
         return _list_once()
     try:
@@ -296,7 +299,7 @@ def _list_once() -> int:
     for qp in pending:
         sys.stdout.write(
             f"{qp.proposal.arrival_timestamp}  "
-            f"[{qp.label}]  "
+            f"[{qp.proposal.bottle_slug}]  "
             f"{qp.proposal.tool}  "
             f"{qp.proposal.id}\n"
         )
@@ -393,7 +396,7 @@ def _main_loop(stdscr: "curses._CursesWindow") -> None:  # type: ignore  # pragm
             reason = _prompt(stdscr, "reject reason: ")
             if reason:
                 reject(qp, reason=reason)
-                status_line = f"rejected {qp.proposal.tool} for [{qp.label}]"
+                status_line = f"rejected {qp.proposal.tool} for [{qp.proposal.bottle_slug}]"
             else:
                 status_line = "reject aborted (empty reason)"
 
@@ -432,7 +435,7 @@ def _render(
             cursor = "> " if i == selected else "  "
             line = (
                 f"{cursor}{ts_short}  "
-                f"[{qp.label}]  {p.tool:<18}  {p.id[:8]}"
+                f"[{p.bottle_slug}]  {p.tool:<18}  {p.id[:8]}"
             )
             attr = curses.A_REVERSE if i == selected else curses.A_NORMAL
             stdscr.addnstr(row, 0, line, w - 1, attr)

bot_bottle/contrib/claude/agent_provider.py

@@ -4,7 +4,7 @@ The Claude-specific behavior previously inlined under
 `agent_provider.agent_provision_plan` (claude.json trust marker,
 api.anthropic.com egress route, OAuth-token placeholder), plus
 the `claude mcp add` invocation that registers the supervise
-gateway in claude-code's user config (PRD 0013)."""
+sidecar in claude-code's user config (PRD 0013)."""
 
 from __future__ import annotations
 
@@ -32,8 +32,6 @@ if TYPE_CHECKING:
 
 
 _SUPERVISE_MCP_NAME = "supervise"
-# App-layer identity token header (mirrors egress_addon / git_http_backend).
-_IDENTITY_HEADER = "x-bot-bottle-identity"
 
 
 def _skills_dir(guest_home: str) -> str:
@@ -93,7 +91,6 @@ _RUNTIME = AgentProviderRuntime(
     prompt_mode="append_file",
     bypass_args=("--dangerously-skip-permissions",),
     resume_args=("--continue",),
-    smoke_test=("claude", "--version"),
 )
 
 
@@ -296,22 +293,16 @@ class ClaudeAgentProvider(AgentProvider):
         supervise_url: str,
     ) -> None:
         """Run `claude mcp add` inside the agent guest to register the
-        supervise daemon in claude-code's user config (~/.claude.json).
+        supervise sidecar in claude-code's user config (~/.claude.json).
 
         Failure is logged but not fatal — the bottle still works without
         the entry; the operator can register it manually."""
         if plan.supervise_plan is None:
             return
         info(f"registering supervise MCP server in agent claude config → {supervise_url}")
-        # Deliver the identity token as an MCP request header — the supervise
-        # daemon requires it (mandatory (source_ip, token) attribution).
-        token = getattr(plan, "identity_token", "")
-        header = (
-            f" --header {shlex.quote(f'{_IDENTITY_HEADER}: {token}')}" if token else ""
-        )
         r = bottle.exec(
             f"claude mcp add --scope user --transport http "
-            f"{_SUPERVISE_MCP_NAME} {supervise_url}{header}",
+            f"{_SUPERVISE_MCP_NAME} {supervise_url}",
             user="node",
         )
         if r.returncode != 0:

bot_bottle/contrib/codex/agent_provider.py

@@ -4,12 +4,11 @@ The Codex-specific behavior previously inlined under
 `agent_provider.agent_provision_plan` (config.toml trust marker,
 chatgpt.com / api.openai.com egress routes, optional host-credential
 forwarding with dummy-auth.json + verify), plus the `codex mcp add`
-invocation that registers the supervise daemon in Codex's
+invocation that registers the supervise sidecar in Codex's
 ~/.codex/config.toml (PRD 0050)."""
 
 from __future__ import annotations
 
-import base64
 import os
 import shlex
 from pathlib import Path
@@ -27,7 +26,7 @@ from ...agent_provider import (
 )
 from .codex_auth import codex_host_access_token, write_codex_dummy_auth_file
 from ...egress import CODEX_HOST_CREDENTIAL_TOKEN_REF, EgressRoute
-from ...log import die, info
+from ...log import die, info, warn
 
 
 if TYPE_CHECKING:
@@ -35,8 +34,6 @@ if TYPE_CHECKING:
 
 
 _SUPERVISE_MCP_NAME = "supervise"
-# App-layer identity token header (mirrors egress_addon / git_http_backend).
-_IDENTITY_HEADER = "x-bot-bottle-identity"
 _CODEX_CLI = "/home/node/.codex/packages/standalone/current/bin/codex"
 _CODEX_CLI_PATH = (
     "/home/node/.local/bin:"
@@ -45,41 +42,6 @@ _CODEX_CLI_PATH = (
 )
 
 
-def _toml_basic_string(value: str) -> str:
-    """Quote `value` as a TOML basic (double-quoted) string."""
-    escaped = (
-        value.replace("\\", "\\\\")
-        .replace('"', '\\"')
-        .replace("\n", "\\n")
-        .replace("\t", "\\t")
-    )
-    return f'"{escaped}"'
-
-
-def _supervise_mcp_config_toml(supervise_url: str, token: str) -> str:
-    """Render the `[mcp_servers.supervise]` streamable-HTTP entry for
-    Codex's `config.toml`.
-
-    The Codex CLI has no `mcp add --header` flag; a static request
-    header on an HTTP MCP server is only expressible via the
-    `http_headers` config key (see `RawMcpServerConfig` /
-    `McpServerTransportConfig::StreamableHttp`). We deliver the
-    mandatory identity token (source_ip, token attribution) that way.
-    Only Codex-supported streamable-HTTP keys (`url`, `http_headers`)
-    are emitted."""
-    lines = [
-        "",
-        f"[mcp_servers.{_SUPERVISE_MCP_NAME}]",
-        f"url = {_toml_basic_string(supervise_url)}",
-    ]
-    if token:
-        key = _toml_basic_string(_IDENTITY_HEADER)
-        val = _toml_basic_string(token)
-        lines.append(f"http_headers = {{ {key} = {val} }}")
-    lines.append("")
-    return "\n".join(lines)
-
-
 def _skills_dir(guest_home: str) -> str:
     # Codex agents still read skills from the claude-code convention
     # (~/.claude/skills/) — the bot-bottle-codex image follows the
@@ -99,7 +61,6 @@ _RUNTIME = AgentProviderRuntime(
     prompt_mode="read_prompt_file",
     bypass_args=("--dangerously-bypass-approvals-and-sandbox",),
     resume_args=("resume", "--last"),
-    smoke_test=(_CODEX_CLI, "--version"),
 )
 
 
@@ -304,39 +265,25 @@ class CodexAgentProvider(AgentProvider):
         bottle: "Bottle",
         supervise_url: str,
     ) -> None:
-        """Register the supervise daemon as a streamable-HTTP MCP
+        """Run `codex mcp add` inside the agent guest to register the
-        server in Codex's user config (`~/.codex/config.toml`).
+        supervise sidecar in Codex's user config (~/.codex/config.toml).
 
-        We write the `[mcp_servers.supervise]` entry directly rather
+        Mirrors the Claude provider's `claude mcp add` flow — failure
-        than shelling out to `codex mcp add`: the CLI's `add` has no
+        is logged but not fatal."""
-        way to attach a static request header, and the identity token
-        (mandatory (source_ip, token) attribution) MUST ride on the
-        MCP request as `http_headers`. Failure is FATAL when supervise
-        is enabled — a silently-unregistered server leaves the agent
-        with no supervise access and, under mandatory attribution, no
-        way to recover from inside the bottle."""
         if plan.supervise_plan is None:
             return
         info(f"registering supervise MCP server in agent codex config → {supervise_url}")
-        token = getattr(plan, "identity_token", "")
+        r = bottle.exec(
-        block = _supervise_mcp_config_toml(supervise_url, token)
+            f"{shlex.quote(_CODEX_CLI)} mcp add {_SUPERVISE_MCP_NAME} --url "
-        auth_dir = plan.agent_provision.guest_env.get("CODEX_HOME") \
+            f"{shlex.quote(supervise_url)}",
-            or f"{plan.guest_home}/.codex"
+            user="node",
-        config_path = f"{auth_dir}/config.toml"
-        # Append via base64 so the TOML payload never has to survive a
-        # shell-quoting round trip. node owns the config file, so append
-        # as node to preserve ownership/mode.
-        payload = base64.b64encode(block.encode()).decode()
-        script = (
-            f"printf %s {shlex.quote(payload)} | base64 -d "
-            f">> {shlex.quote(config_path)}"
         )
-        r = bottle.exec(script, user="node")
         if r.returncode != 0:
-            die(
+            warn(
-                "agent provider provisioning: could not register supervise "
+                f"`codex mcp add supervise` failed (exit {r.returncode}): "
-                f"MCP server in {config_path}: "
+                f"{(r.stderr or r.stdout or '').strip()}. Inside the bottle, "
-                f"{(r.stderr or r.stdout or '').strip()}"
+                f"register manually with: "
+                f"codex mcp add supervise --url {shlex.quote(supervise_url)}"
             )
 
     def headless_prompt(self, prompt: str) -> list[str]:

bot_bottle/dlp_detectors.py

@@ -3,7 +3,7 @@
 Pure Python, no mitmproxy dependency. Each detector is a module-level
 function returning `ScanResult | None`.
 
-Ships flat into the gateway image alongside
+Ships flat into the sidecar bundle image alongside
 `egress_addon_core.py` — both this file and the package source use
 the same try/except import shim pattern.
 """

bot_bottle/egress.py

@@ -2,7 +2,7 @@
 
 This module defines the abstract proxy (`Egress`), its plan
 dataclass (`EgressPlan`), and the resolved per-route shape
-(`EgressRoute`). The gateway's start/stop lifecycle is backend-
+(`EgressRoute`). The sidecar's start/stop lifecycle is backend-
 specific and lives on concrete subclasses (see
 `bot_bottle/backend/docker/egress.py`).
 """
@@ -63,8 +63,8 @@ def _random_canary_env() -> str:
     return f"{first}_{second}_SECRET"
 
 
-def egress_gateway_env_entries(plan: "EgressPlan") -> tuple[str, ...]:
+def egress_sidecar_env_entries(plan: "EgressPlan") -> tuple[str, ...]:
-    """Return gateway env entries needed by egress across all backends."""
+    """Return sidecar env entries needed by egress across all backends."""
     env: list[str] = []
     if plan.routes:
         env.extend(sorted(plan.token_env_map.keys()))
@@ -87,7 +87,7 @@ class EgressRoute(Route):
 
     Inherits `host`, `matches`, `auth_scheme`, and `token_env`
     from `egress_addon_core.Route` — those are the fields that cross the
-    YAML wire into the gateway. The fields below are host-only and
+    YAML wire into the sidecar. The fields below are host-only and
     are never serialised to the addon.
 
     `token_ref` is the host env var the CLI reads at launch and forwards
@@ -386,7 +386,7 @@ class Egress(ABC):
         routes_path.write_text(egress_render_routes(routes, log=log))
         routes_path.chmod(0o600)
         # Generate a per-session fake secret under a plausible random env name.
-        # The gateway marks that exact env name as sensitive for known-secret
+        # The sidecar marks that exact env name as sensitive for known-secret
         # scanning; the agent receives the same name/value as exfil bait.
         canary = secrets.token_urlsafe(32)
         return EgressPlan(
@@ -412,6 +412,6 @@ __all__ = [
     "egress_resolve_token_values",
     "egress_routes_for_bottle",
     "egress_agent_env_entries",
-    "egress_gateway_env_entries",
+    "egress_sidecar_env_entries",
     "egress_token_env_map",
 ]

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."""
@@ -6,13 +6,10 @@ egress container."""
 from __future__ import annotations
 
 import asyncio
-import base64
-import binascii
 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
@@ -35,7 +32,7 @@ from egress_addon_core import (  # type: ignore[import-not-found]  # pylint: dis
     is_git_push_request,
     load_config,
     match_route,
-    resolve_client_context,
+    resolve_client_config,
     outbound_scan_headers,
     route_to_yaml_dict,
     scan_inbound,
@@ -71,28 +68,10 @@ INTROSPECT_HOST = "_egress.local"
 # → legacy per-bottle single-tenant mode (unchanged).
 ORCHESTRATOR_URL_ENV = "BOT_BOTTLE_ORCHESTRATOR_URL"
 
-# App-layer identity token. Delivered as proxy credentials
+# App-layer identity token (defense-in-depth over the source-IP invariant);
-# (`HTTPS_PROXY=http://<bottle_id>:<token>@gw`): clients honor it as part of
+# the agent injects it, the addon strips it so it never leaks upstream.
-# the proxy protocol without app changes, and the addon reads + strips it so
-# it never leaks upstream. The legacy `x-bot-bottle-identity` request header
-# is still stripped defensively (git-http uses that header on its own port).
 IDENTITY_HEADER = "x-bot-bottle-identity"
 
-
-def _token_from_proxy_auth(header: str) -> str:
-    """Extract the identity token (the password) from a `Proxy-Authorization:
-    Basic base64(<bottle_id>:<token>)` header. Empty on any malformed value —
-    the mandatory `/resolve` then fail-closes on the empty token."""
-    scheme, _, encoded = header.partition(" ")
-    if scheme.lower() != "basic" or not encoded:
-        return ""
-    try:
-        decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
-    except (binascii.Error, ValueError, UnicodeDecodeError):
-        return ""
-    _, _, password = decoded.partition(":")
-    return password
-
 # 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
@@ -112,10 +91,6 @@ 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
-    # Class default so __new__-built addons have it (real runs get a fresh
-    # per-instance dict in __init__; only http_connect mutates it, which the
-    # request-flow tests don't exercise).
-    _conn_tokens: "dict[str, str]" = {}
 
     def __init__(self) -> None:
         self.routes_path = os.environ.get("EGRESS_ROUTES", DEFAULT_ROUTES_PATH)
@@ -124,33 +99,17 @@ class EgressAddon:
         # 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
+        # Tokens the operator has approved this session (PRD 0062). In-memory
-        # bottle so the shared gateway keeps each bottle's safelist separate —
+        # only — a restart re-prompts. Mutated only from the asyncio loop that
-        # a global set would let bottle A's approved secret pass bottle B's DLP
+        # runs the addon hooks, so no lock is needed.
-        # scan. In-memory only (a restart re-prompts); mutated only from the
+        self.safe_tokens: set[str] = set()
-        # asyncio loop that runs the addon hooks, so no lock is needed.
-        self._safe_tokens: dict[str, set[str]] = {}
-        # Per-client-connection identity token captured from the CONNECT's
-        # `Proxy-Authorization` (HTTPS tunnels don't repeat it on the bumped
-        # inner requests). Keyed by client_conn.id; cleared on disconnect.
-        self._conn_tokens: dict[str, str] = {}
         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(self) -> bool:
-    def _supervise_available(slug: str) -> bool:
+        return bool(self._supervise_slug)
-        """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 _reload(self, *, initial: bool = False) -> None:
         try:
@@ -259,57 +218,19 @@ class EgressAddon:
             + "\n"
         )
 
-    def _resolve_flow(
+    def _active_config(self, flow: http.HTTPFlow) -> Config:
-        self, flow: http.HTTPFlow,
+        """The Config to apply to this request. Single-tenant → the static
-    ) -> "tuple[Config, str, typing.Mapping[str, str]]":
+        `self.config`. Consolidated → the calling bottle's Config, resolved
-        """The `(Config, supervise slug, env)` to apply to this request.
+        by source IP (fail-closed to deny-all if unattributed). The identity
-        Single-tenant → the static `self.config`, the env slug, and the process
+        token, if the agent injected one, is read then stripped so it never
-        env. Consolidated → the calling bottle's Config + bottle id + auth
+        leaks upstream."""
-        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 gateway daemon'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
+            return self.config
         conn = flow.client_conn
         client_ip = conn.peername[0] if conn and conn.peername else ""
-        token = self._request_token(flow)
+        token = flow.request.headers.get(IDENTITY_HEADER, "")
-        config, slug, tokens = resolve_client_context(self._resolver, client_ip, token)
-        env = {**os.environ, **tokens} if tokens else os.environ
-        return config, slug, env
-
-    def _request_token(self, flow: http.HTTPFlow) -> str:
-        """The per-bottle identity token for this request, from the proxy
-        credentials — the delivery mechanism (`HTTPS_PROXY=http://id:token@gw`)
-        that clients honor without app changes. Plain-HTTP requests carry
-        `Proxy-Authorization` directly; HTTPS bumped requests inherit the token
-        captured from their tunnel's CONNECT. Read then stripped so it never
-        leaks upstream (also strips the legacy header, if present)."""
-        token = _token_from_proxy_auth(
-            flow.request.headers.get("Proxy-Authorization", ""))
-        flow.request.headers.pop("Proxy-Authorization", None)
         flow.request.headers.pop(IDENTITY_HEADER, None)
-        conn = flow.client_conn
+        return resolve_client_config(self._resolver, client_ip, token)
-        if not token and conn is not None:
-            token = self._conn_tokens.get(getattr(conn, "id", ""), "")
-        return token
-
-    def http_connect(self, flow: http.HTTPFlow) -> None:
-        """Capture the identity token from an HTTPS tunnel's CONNECT (the inner
-        bumped requests won't carry `Proxy-Authorization`), keyed by client
-        connection, and strip it so it never reaches upstream."""
-        token = _token_from_proxy_auth(
-            flow.request.headers.get("Proxy-Authorization", ""))
-        flow.request.headers.pop("Proxy-Authorization", None)
-        conn = flow.client_conn
-        if conn is not None and getattr(conn, "id", ""):
-            self._conn_tokens[conn.id] = token
-
-    def client_disconnected(self, client: typing.Any) -> None:
-        """Drop the per-connection token when the client goes away."""
-        self._conn_tokens.pop(getattr(client, "id", ""), None)
 
     async def request(self, flow: http.HTTPFlow) -> None:
         request_path, _, query = flow.request.path.partition("?")
@@ -318,14 +239,14 @@ class EgressAddon:
             self._serve_introspection(flow, request_path)
             return
 
-        config, slug, env = self._resolve_flow(flow)
+        config = self._active_config(flow)
 
         # DLP outbound scan BEFORE stripping auth — catches tokens the
         # agent tried to smuggle in any header, path, query param, or body.
         # Hostname is included to catch DNS-tunnelling exfiltration attempts.
         route = match_route(config.routes, flow.request.pretty_host)
         if route is not None:
-            if not await self._handle_outbound_dlp(flow, route, slug, env):
+            if not await self._handle_outbound_dlp(flow, route):
                 return
             # The redact policy may have rewritten the request line; recompute
             # the path/query the git checks below rely on.
@@ -354,7 +275,7 @@ 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
@@ -364,7 +285,7 @@ class EgressAddon:
             config.routes,
             flow.request.pretty_host,
             request_path,
-            env,
+            os.environ,
             request_method=flow.request.method,
             request_headers=req_headers,
         )
@@ -389,13 +310,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
+        (PRD 0062). Returns True if the request may be forwarded, False if a
-        bottle's tokens) used for DLP detection. Returns True if the request may
+        403 response has been written to `flow`.
-        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."""
@@ -412,8 +330,8 @@ class EgressAddon:
                 flow.request.pretty_host, request_path, query, headers, "",
             )
             result = scan_outbound(
-                route, scan_text, env,
+                route, scan_text, os.environ,
-                safe_tokens=self._safe_tokens_for(slug), crlf_text=crlf_text,
+                safe_tokens=self.safe_tokens, crlf_text=crlf_text,
             )
             if result is None or result.severity != "block":
                 return True
@@ -423,7 +341,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",
@@ -448,34 +366,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(
+    def _redact_outbound(self, flow: http.HTTPFlow, route: Route) -> bool:
-        self, flow: http.HTTPFlow, route: Route, env: "typing.Mapping[str, str]",
-    ) -> bool:
         """Scrub detected tokens (and CRLF injection sequences) from the mutable
-        request surfaces (body, headers, path/query) and re-scan. `env` is the
+        request surfaces (body, headers, path/query) and re-scan. Returns True
-        per-bottle env overlay. Returns True if the request is now clean; False
+        if the request is now clean; False if a block-severity match remains on
-        if a block-severity match remains on a surface redaction cannot rewrite
+        a surface redaction cannot rewrite (the hostname) so the caller fails
-        (the hostname) so the caller fails closed."""
+        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
 
@@ -488,7 +404,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(
@@ -496,27 +412,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 +
+        Returns True if the operator approved (the matched value is added to
-        safelist) — in the shared gateway this is what keeps one bottle's
+        `self.safe_tokens` and the caller re-scans); False if the request must
-        approval from unblocking another's request. `env` is the per-bottle env
+        be blocked (a 403 response has been written to `flow`)."""
-        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`)."""
         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,
@@ -539,13 +449,13 @@ class EgressAddon:
             **self._req_ctx(flow),
         }) + "\n")
 
-        response = await self._await_token_response(proposal.id, slug)
+        response = await self._await_token_response(proposal.id)
-        _sv.archive_proposal(slug, 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",
@@ -568,7 +478,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."""
@@ -576,7 +485,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.
@@ -630,9 +539,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
@@ -643,7 +549,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,12 +3,12 @@
 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
-ships flat into the gateway image alongside this file —
+ships flat into the sidecar bundle image alongside this file —
-see `Dockerfile.gateway`)."""
+see `Dockerfile.sidecars`)."""
 
 from __future__ import annotations
 
@@ -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.gateway). 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.
@@ -421,18 +421,6 @@ class PolicyResolverLike(typing.Protocol):
         ...
 
 
-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":
@@ -445,36 +433,12 @@ def resolve_client_config(
         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)
+    if not policy:
-
+        return Config(routes=())  # unattributed or empty → deny-all
-
-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(
+        return load_config(policy)
-            client_ip, identity_token,
+    except ValueError:
-        )
+        return Config(routes=())  # unparseable policy → deny
-    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
 
 
 # ---------------------------------------------------------------------------
@@ -677,7 +641,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 +692,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,
@@ -869,9 +833,7 @@ __all__ = [
     "is_git_fetch_request",
     "load_config",
     "resolve_client_config",
-    "resolve_client_context",
     "PolicyResolverLike",
-    "ContextResolverLike",
     "match_route",
     "outbound_scan_headers",
     "parse_config",

bot_bottle/egress_dlp_config.py

@@ -6,8 +6,8 @@ and what the proxy does when an outbound detector matches a token
 kept apart from the request-time scan/decision flow in `egress_addon_core`
 so each half reads top-to-bottom without scrolling past the other.
 
-Stdlib-only; ships flat into the gateway image alongside
+Stdlib-only; ships flat into the sidecar bundle image alongside
-`egress_addon_core.py` — see `Dockerfile.gateway`."""
+`egress_addon_core.py` — see `Dockerfile.sidecars`."""
 
 from __future__ import annotations
 

bot_bottle/egress_entrypoint.sh

@@ -1,8 +1,8 @@
 #!/bin/sh
-# Egress daemon entrypoint inside the gateway (PRD 0024).
+# Egress daemon entrypoint inside the sidecar bundle (PRD 0024).
 #
 # Extracted verbatim from Dockerfile.egress's prior inline `sh -c`
-# ENTRYPOINT so the supervisor in bot_bottle/gateway_init.py can
+# ENTRYPOINT so the supervisor in bot_bottle/sidecar_init.py can
 # call it as a normal child. Behavior is unchanged:
 #
 #   * Upstream proxy: when EGRESS_UPSTREAM_PROXY is set, switch
@@ -22,7 +22,7 @@ set -e
 
 # Pin mitmproxy's config dir to the bind-mount location of its CA
 # regardless of which user mitmdump runs as. In the legacy
-# four-daemon setup (Dockerfile.egress, USER mitmproxy) this
+# four-sidecar setup (Dockerfile.egress, USER mitmproxy) this
 # resolved naturally to `~mitmproxy/.mitmproxy`. In the PRD 0024
 # bundle (USER root) `~root/.mitmproxy` is empty, so without this
 # flag mitmdump would generate a fresh CA on the wrong path and

bot_bottle/git_gate.py

@@ -1,6 +1,6 @@
 """Per-agent git-gate (PRD 0008).
 
-A third per-agent daemon that fronts the bottle's declared git
+A third per-agent sidecar that fronts the bottle's declared git
 upstreams as a transparent mirror. Each `bottle.git` entry maps to
 a bare repo on the gate; `git daemon` serves the bare repos over
 `git://<gate>/<name>.git`. Two hooks make the mirror bidirectional:
@@ -15,7 +15,7 @@ a bare repo on the gate; `git daemon` serves the bare repos over
 
 The agent never sees the upstream credential under either path.
 
-Why a separate daemon (not folded into egress or ssh-gate): the
+Why a separate sidecar (not folded into egress or ssh-gate): the
 gate is the only one of the three that holds upstream push
 credentials. Mixing it with egress would put push creds in the
 same blast radius as internet-facing TLS interception; mixing it
@@ -23,7 +23,7 @@ with ssh-gate would force ssh-gate above L4 and into git-protocol
 land. See `docs/prds/0008-git-gate.md`.
 
 This module defines the abstract gate (`GitGate`) and its plan
-dataclass (`GitGatePlan`). The gateway's start/stop lifecycle is
+dataclass (`GitGatePlan`). The sidecar's start/stop lifecycle is
 backend-specific and lives on concrete subclasses (see
 `bot_bottle/backend/docker/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,
@@ -86,7 +85,7 @@ class GitGatePlan:
 
 class GitGate(ABC):
     """The per-agent git-gate. Encapsulates the host-side prepare
-    (upstream lift + entrypoint/hook render); the gateway's
+    (upstream lift + entrypoint/hook render); the sidecar's
     start/stop lifecycle is backend-specific and lives on concrete
     subclasses."""
 
@@ -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_provision.py

@@ -13,7 +13,6 @@ import dataclasses
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from .bottle_state import globalize_slug
 from .errors import MissingEnvVarError
 from .log import info
 from .manifest import ManifestBottle, ManifestGitEntry
@@ -47,7 +46,7 @@ def _provision_dynamic_key(
     owner_repo = entry.UpstreamPath
     if owner_repo.endswith(".git"):
         owner_repo = owner_repo[:-4]
-    title = f"bot-bottle:{globalize_slug(slug)}:{entry.Name}"
+    title = f"bot-bottle:{slug}:{entry.Name}"
 
     info(f"provisioning deploy key for git-gate.repos[{entry.Name!r}]")
     key_id, private_key_bytes = provisioner.create(owner_repo, title)

bot_bottle/git_gate_render.py

@@ -1,7 +1,7 @@
 """Pure host-side rendering for the per-agent git-gate (PRD 0008).
 
 Builds the agent's `.gitconfig` insteadOf rewrites, the known_hosts
-line, and the entrypoint / pre-receive / access-hook scripts the gateway
+line, and the entrypoint / pre-receive / access-hook scripts the sidecar
 runs. No docker or forge calls — exposed for tests and reuse across
 backends. Split out of `git_gate.py` so the control surface (`GitGate`)
 and the deploy-key lifecycle (`git_gate_provision`) each read on their
@@ -9,19 +9,15 @@ 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
 
 from .manifest import ManifestBottle, ManifestGitEntry
 
-# Short network alias for git-gate inside the gateway. The
+# Short network alias for git-gate inside the sidecar bundle. The
 # agent's `.gitconfig` insteadOf rewrites resolve through this name.
 GIT_GATE_HOSTNAME = "git-gate"
-# App-layer identity token header the agent's git sends to git-http and the
-# gateway validates (mirrors egress_addon / git_http_backend IDENTITY_HEADER).
-IDENTITY_HEADER = "x-bot-bottle-identity"
 # Shared timeout (seconds) for all git-gate subprocess and CGI calls:
 # git daemon (--timeout/--init-timeout), the access-hook subprocess in
 # git_http_backend, and the git http-backend CGI subprocess.
@@ -41,7 +37,7 @@ class GitGateUpstream:
     KnownHostKey string from the manifest; the gate's start step
     materialises it into a known_hosts file if non-empty.
 
-    the gate credential paths inside the running gateway."""
+    the gate credential paths inside the running sidecar."""
 
     name: str
     upstream_url: str
@@ -78,7 +74,6 @@ def _gitconfig_validate_value(field: str, value: str) -> None:
 
 def git_gate_render_gitconfig(
     entries: tuple[ManifestGitEntry, ...], gate_host: str, *, scheme: str = "git",
-    identity_token: str = "",
 ) -> str:
     """Render the agent's ~/.gitconfig content for git-gate
     `insteadOf` rewrites. Pure host-side, no docker / VM;
@@ -100,15 +95,6 @@ def git_gate_render_gitconfig(
         "# the upstream bidirectionally (gitleaks-scanned push;\n",
         "# fetch-from-upstream-before-every-upload-pack via access-hook).\n",
     ]
-    # Over the smart-HTTP transport (VM backends), attach the per-bottle
-    # identity token as a request header on requests to the gate, scoped to
-    # its URL so it never goes to any other remote. git-http requires it (the
-    # gateway's mandatory (source_ip, token) attribution). git:// (single-tenant
-    # docker) carries no header — attribution there is the network alias.
-    if identity_token and scheme == "http":
-        _gitconfig_validate_value("identity_token", identity_token)
-        out.append(f'[http "http://{gate_host}/"]\n')
-        out.append(f"\textraHeader = {IDENTITY_HEADER}: {identity_token}\n")
     for entry in entries:
         _gitconfig_validate_value(f"repos[{entry.Name!r}].url", entry.Upstream)
         out.append(f'[url "{scheme}://{gate_host}/{entry.Name}.git"]\n')
@@ -139,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]:
+def git_gate_render_entrypoint(upstreams: tuple[GitGateUpstream, ...]) -> str:
-    """The `init_repo` shell function, parameterized by the bare-repo root
+    """Posix-sh entrypoint. One `init_repo` call per upstream, then
-    and the per-bottle creds dir. Single source of the credential-wiring
+    `exec git daemon`. The function reads
-    logic, shared by the single-tenant daemon entrypoint (`/git`,
+    `/git-gate/creds/<name>-{key,known_hosts}` (bind-mounted into
-    `/git-gate/creds`) and the consolidated per-bottle provisioning
+    the bundle by the renderer) and wires them into each bare repo's
-    (`/git/<bottle_id>`, `/git-gate/creds/<bottle_id>`)."""
+    config; the access-hook + pre-receive hook pick those paths up
-    return [
+    at fetch / push time."""
+    lines = [
+        "#!/bin/sh",
+        "set -eu",
+        "",
         "init_repo() {",
         "  name=$1",
         "  upstream_url=$2",
-        f"  keyfile={creds_dir}/${{name}}-key",
+        "  keyfile=/git-gate/creds/${name}-key",
-        f"  hostsfile={creds_dir}/${{name}}-known_hosts",
+        "  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
@@ -163,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
+        # --mirror=fetch sets remote.origin.fetch = +refs/*:refs/* so",
-        # `git fetch origin` mirrors the upstream's full ref graph (heads,
+        # a later `git fetch origin` mirrors the upstream's full ref",
-        # tags, notes) into the bare repo at canonical paths. It does NOT set
+        # graph (heads, tags, notes) into the bare repo at canonical",
-        # remote.origin.mirror=true, so an explicit `git push origin
+        # paths. It does NOT set remote.origin.mirror=true, so an",
-        # <ref>:<ref>` still pushes one ref.
+        # 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\"",
@@ -180,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([
@@ -210,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

@@ -2,19 +2,10 @@
 
 Used where `git://` push traffic over a host-published Docker port can
 hang before receive-pack reaches hooks (e.g. the firecracker backend,
-where the guest reaches the gateway over the point-to-point TAP). The
+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,89 +13,16 @@ 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 gateway
-# image (see Dockerfile.gateway); 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 gateway
+# imported: this module ships as a flat top-level sibling in the sidecar
-# bundle image (see Dockerfile.gateway), not as part of the bot_bottle
+# bundle image (see Dockerfile.sidecars), not as part of the bot_bottle
 # package, so `bot_bottle.git_gate` and its dependency chain aren't
 # available at runtime.
 GIT_GATE_TIMEOUT_SECS = 15
@@ -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:
+    def _repo_dir(self, path: str) -> Path | None:
-        root = sandbox_root.resolve()
+        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()
+    sys.stdout.write(f"git-http listening on 0.0.0.0:{port}\n")
-    # 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.flush()
     server.serve_forever()
     return 0

bot_bottle/manifest_agent.py

@@ -17,7 +17,7 @@ class ManifestAgentProvider:
 
     `template` selects a built-in launch/runtime contract. `dockerfile`
     optionally points at a custom agent-image Dockerfile while leaving
-    bot-bottle's gateway infrastructure intact.
+    bot-bottle's sidecar infrastructure intact.
 
     `auth_token` names the host env var that holds the provider's OAuth
     token (Claude only). The provisioner injects a provider-owned egress
@@ -26,7 +26,7 @@ class ManifestAgentProvider:
     so the Claude Code CLI starts.
 
     `forward_host_credentials` forwards the host Codex auth token into
-    the egress daemon (Codex only).
+    the egress sidecar (Codex only).
     """
 
     template: str = "claude"

bot_bottle/manifest_bottle.py

@@ -39,10 +39,10 @@ class ManifestBottle:
     # identity without any git-gate.repos upstreams, and vice versa.
     git_user: ManifestGitUser = field(default_factory=ManifestGitUser)
     egress: ManifestEgressConfig = field(default_factory=ManifestEgressConfig)
-    # Per-bottle stuck-recovery daemon (PRD 0013). When true (the
+    # Per-bottle stuck-recovery sidecar (PRD 0013). When true (the
     # default, issue #249), the launch step brings up a supervise
-    # daemon that exposes egress MCP tools to the agent. Set
+    # sidecar that exposes egress MCP tools to the agent. Set
-    # `supervise: false` to skip the gateway.
+    # `supervise: false` to skip the sidecar.
     supervise: bool = True
 
     @classmethod
@@ -61,7 +61,7 @@ class ManifestBottle:
             raise ManifestError(
                 f"bottle '{name}' has an 'ssh' field, which has been removed "
                 f"(PRD 0009). Declare upstreams under 'git-gate.repos' with "
-                f"url + identity + host_key; the git-gate daemon (PRD 0008) "
+                f"url + identity + host_key; the git-gate sidecar (PRD 0008) "
                 f"holds the credential and gitleaks-scans pushes."
             )
 

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",
+    "Sidecar",
-    "DockerGateway",
+    "DockerSidecar",
-    "GatewayError",
+    "SidecarError",
     "sign_request",
     "verify_request",
     "Orchestrator",

bot_bottle/orchestrator/__main__.py

@@ -16,13 +16,12 @@ import secrets
 from pathlib import Path
 
 from .. import log
-from ..store_manager import StoreManager
 from .broker import LaunchBroker, StubBroker
 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:
@@ -39,38 +38,27 @@ 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 gateway (build-if-missing)",
+        help="run one consolidated per-host sidecar bundle (build-if-missing)",
     )
     args = parser.parse_args(argv)
 
     registry = RegistryStore(args.db)
     registry.migrate()
-    # One DB per host: the supervise queue + audit tables live in the SAME
-    # SQLite file the registry owns, so the control plane is the single
-    # source of truth. The in-VM supervise daemon writes here; the host
-    # operator reaches it over HTTP (never a second, disconnected DB).
-    StoreManager(registry.db_path).migrate()
 
     # An ephemeral signing secret ties the orchestrator (signer) to its
     # broker (verifier). 'stub' records launches instead of starting
     # 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
+    sidecar: Sidecar | None = DockerSidecar() if args.sidecar else None
-    # lifecycle runs the gateway). The gateway resolves against this same
+    orchestrator = Orchestrator(registry, broker, secret, sidecar)
-    # 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)
 
-    # 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:
+    if sidecar is not None:
-        orchestrator.ensure_gateway()
+        orchestrator.ensure_sidecar()
-        log.info("consolidated gateway ensured", context={"name": gateway.name})
+        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,205 +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 []
-
-    # --- supervise queue (operator TUI) ------------------------------------
-
-    def supervise_pending(self) -> list[dict[str, object]]:
-        """Pending supervise proposals across all bottles
-        (`GET /supervise/proposals`)."""
-        payload = self._ok("GET", "/supervise/proposals")
-        proposals = payload.get("proposals")
-        return proposals if isinstance(proposals, list) else []
-
-    def supervise_respond(
-        self,
-        proposal_id: str,
-        *,
-        bottle_slug: str,
-        decision: str,
-        notes: str = "",
-        final_file: str | None = None,
-    ) -> None:
-        """Record an operator decision (`POST /supervise/respond`). `decision`
-        is approve/modify/reject. Raises `OrchestratorClientError` if the
-        proposal is gone or the bottle can no longer be applied to (409)."""
-        body: dict[str, object] = {
-            "proposal_id": proposal_id,
-            "bottle_slug": bottle_slug,
-            "decision": decision,
-            "notes": notes,
-        }
-        if final_file is not None:
-            body["final_file"] = final_file
-        self._ok("POST", "/supervise/respond", body)
-
-
-def discover_orchestrator_url(*, timeout: float = 2.0) -> str:
-    """The URL of the one running per-host orchestrator control plane, probing
-    the backends' well-known control-plane addresses (both on port 8099):
-    docker publishes it on loopback; the firecracker infra VM serves it on the
-    orchestrator TAP. Returns the first that answers `/health`; raises if none
-    do (no orchestrator up — launch a bottle first)."""
-    candidates: list[str] = []
-    try:  # docker: loopback-published control plane
-        from .lifecycle import DEFAULT_PORT as _DOCKER_PORT
-        candidates.append(f"http://127.0.0.1:{_DOCKER_PORT}")
-    except Exception:  # noqa: BLE001 — backend optional
-        candidates.append("http://127.0.0.1:8099")
-    try:  # firecracker: infra VM control plane on the orchestrator TAP
-        from ..backend.firecracker import netpool
-        from ..backend.firecracker.infra_vm import CONTROL_PLANE_PORT
-        candidates.append(
-            f"http://{netpool.orch_slot().guest_ip}:{CONTROL_PLANE_PORT}")
-    except Exception:  # noqa: BLE001 — backend optional / not firecracker
-        pass
-    for url in candidates:
-        if OrchestratorClient(url, timeout=timeout).health():
-            return url
-    raise OrchestratorClientError(
-        "no running orchestrator control plane found (tried "
-        + ", ".join(candidates)
-        + "); launch a bottle first"
-    )
-
-
-__all__ = [
-    "OrchestratorClient",
-    "OrchestratorClientError",
-    "RegisteredBottle",
-    "DEFAULT_TIMEOUT_SECONDS",
-    "discover_orchestrator_url",
-]

bot_bottle/orchestrator/control_plane.py

@@ -5,7 +5,7 @@ The backend-agnostic control-plane RPC (CLI / console -> orchestrator) over
 vsock / unix-socket portability caveats):
 
     GET    /health                    -> 200 {"status": "ok"}
-    GET    /gateway                   -> 200 {"configured", ["name","running"]}
+    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"],
@@ -16,10 +16,6 @@ vsock / unix-socket portability caveats):
     POST   /attribute                 -> 200 {"bottle_id"} | 403
     POST   /resolve                   -> 200 {"bottle_id","policy"} | 403
                                          body: {"source_ip","identity_token"}
-    GET    /supervise/proposals       -> 200 {"proposals": [ <proposal>, ...]}
-    POST   /supervise/respond         -> 200 {"responded": true} | 409  (operator)
-                                         body: {"proposal_id","bottle_slug",
-                                                "decision", ["notes"],["final_file"]}
 
 `POST /bottles` / `DELETE` drive the full launch lifecycle: they mint (or
 tear down) the bottle in the registry AND broker the backend-native launch
@@ -38,7 +34,6 @@ import http.server
 import json
 import os
 import socketserver
-import sys
 import typing
 from urllib.parse import urlsplit
 
@@ -68,8 +63,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":
+    if method == "GET" and route == "/sidecar":
-        return 200, orch.gateway_status()
+        return 200, orch.sidecar_status()
 
     if method == "GET" and route == "/bottles":
         return 200, {"bottles": [r.redacted() for r in orch.registry.all()]}
@@ -85,16 +80,11 @@ def dispatch(  # pylint: disable=too-many-return-statements,too-many-branches
         image_ref = data.get("image_ref")
         metadata = data.get("metadata")
         policy = data.get("policy")
-        raw_tokens = data.get("tokens")
-        tokens = {
-            k: v for k, v in raw_tokens.items() if isinstance(k, str) and isinstance(v, str)
-        } if isinstance(raw_tokens, dict) else {}
         rec = orch.launch_bottle(
             source_ip,
             image_ref=image_ref if isinstance(image_ref, str) else "",
             metadata=metadata if isinstance(metadata, str) else "",
             policy=policy if isinstance(policy, str) else "",
-            tokens=tokens,
         )
         return 201, {"bottle_id": rec.bottle_id, "identity_token": rec.identity_token}
 
@@ -131,44 +121,10 @@ def dispatch(  # pylint: disable=too-many-return-statements,too-many-branches
             return 403, {"error": "unattributed"}
         return 200, {"bottle_id": rec.bottle_id}
 
-    if method == "GET" and route == "/supervise/proposals":
-        # Operator TUI: pending supervise proposals across all bottles.
-        return 200, {"proposals": orch.supervise_pending()}
-
-    if method == "POST" and route == "/supervise/respond":
-        # Operator decision: apply (approve/modify rewrites egress policy),
-        # write the queued response, audit — all server-side on the one DB.
-        try:
-            data = _parse_json_object(body)
-        except ValueError as e:
-            return 400, {"error": f"invalid JSON: {e}"}
-        proposal_id = data.get("proposal_id")
-        bottle_slug = data.get("bottle_slug")
-        decision = data.get("decision")
-        if not (isinstance(proposal_id, str) and proposal_id):
-            return 400, {"error": "proposal_id (string) is required"}
-        if not (isinstance(bottle_slug, str) and bottle_slug):
-            return 400, {"error": "bottle_slug (string) is required"}
-        if not (isinstance(decision, str) and decision):
-            return 400, {"error": "decision (string) is required"}
-        notes = data.get("notes")
-        final_file = data.get("final_file")
-        ok, err = orch.supervise_respond(
-            proposal_id,
-            bottle_slug=bottle_slug,
-            decision=decision,
-            notes=notes if isinstance(notes, str) else "",
-            final_file=final_file if isinstance(final_file, str) else None,
-        )
-        if ok:
-            return 200, {"responded": True}
-        return 409, {"error": err}
-
     if method == "POST" and route == "/resolve":
-        # The per-request lookup the multi-tenant gateway makes: returns the
+        # The per-request lookup the multi-tenant sidecar makes: returns the
-        # bottle's policy. Requires a matching (source_ip, identity_token)
+        # bottle's policy. identity_token is OPTIONAL — absent means resolve
-        # pair — a missing/empty/mismatched token fail-closes (403), no
+        # by source IP alone (network-layer attribution).
-        # source-IP-only fallback.
         try:
             data = _parse_json_object(body)
         except ValueError as e:
@@ -180,13 +136,7 @@ def dispatch(  # pylint: disable=too-many-return-statements,too-many-branches
         rec = orch.resolve(source_ip, token if isinstance(token, str) else "")
         if rec is None:
             return 403, {"error": "unattributed"}
-        # tokens are the in-memory per-bottle egress auth values the gateway
+        return 200, {"bottle_id": rec.bottle_id, "policy": rec.policy}
-        # 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"}
 
@@ -201,20 +151,12 @@ class Handler(http.server.BaseHTTPRequestHandler):
             super().log_message(format, *args)
 
     def _serve(self, method: str) -> None:
-        """Read the request body, dispatch it, and write the JSON reply. A
+        """Read the request body, dispatch it, and write the JSON reply."""
-        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."""
         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}"}
         data = json.dumps(payload).encode()
         self.send_response(status)
         self.send_header("Content-Type", "application/json")

bot_bottle/orchestrator/docker_broker.py

@@ -2,12 +2,12 @@
 
 On a verified launch request it starts a Docker container; on teardown it
 removes it. This proves the orchestrator -> backend seam on the cheapest
-backend (the gateway is already containers). Only the request's
+backend (the sidecar bundle is already containers). Only the request's
 static ids/flags reach `docker`, so nothing free-form crosses the boundary.
 
 Slice 3 launches a single container from the request's `image_ref`, named
 after the bottle id and labelled for cleanup. Wiring the full agent +
-gateway (networks, mounts, the consolidated gateway) is a later
+sidecar bundle (networks, mounts, the consolidated sidecar) is a later
 slice — this is the seam, not the finished launcher.
 """
 

bot_bottle/orchestrator/gateway.py

@@ -1,255 +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 gateway 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
-from ..paths import host_db_path
-from ..supervise import DB_PATH_IN_CONTAINER
-
-# The host DB dir is bind-mounted here so the gateway's supervise daemon
-# writes its queued proposals into the ONE host DB (the same file the
-# orchestrator container opens and the operator reaches over HTTP).
-_SUPERVISE_DB_DIR_IN_CONTAINER = os.path.dirname(DB_PATH_IN_CONTAINER)
-
-# 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 gateway data-plane image + its Dockerfile. Kept as a local constant
-# rather than imported from the backend layer, 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_GATEWAY_IMAGE.
-GATEWAY_IMAGE = os.environ.get("BOT_BOTTLE_GATEWAY_IMAGE", "bot-bottle-gateway:latest")
-GATEWAY_DOCKERFILE = "Dockerfile.gateway"
-_REPO_ROOT = Path(__file__).resolve().parents[2]
-
-
-def _host_db_dir() -> str:
-    """The host DB directory (created if missing), for the gateway's
-    supervise-DB bind-mount."""
-    db_dir = host_db_path().parent
-    db_dir.mkdir(parents=True, exist_ok=True)
-    return str(db_dir)
-
-
-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 gateway data-plane image; `ensure_built`
-    builds it from `Dockerfile.gateway` 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,
-        host_port_bindings: tuple[int, ...] = (),
-    ) -> None:
-        self.image_ref = image_ref
-        self.name = name
-        self.network = network
-        # The control-plane URL the gateway's data plane resolves per bottle
-        # against — reached by container name over docker DNS on the shared
-        # network (container↔container, no host firewall). Empty → single-tenant.
-        self._orchestrator_url = orchestrator_url
-        self._build_context = build_context or _REPO_ROOT
-        self._dockerfile = dockerfile
-        # Ports published on the host (0.0.0.0). Used by the Firecracker
-        # backend's dev-harness gateway so VMs can reach it via their TAP link;
-        # Docker's DNAT + the nft `ct status dnat accept` rule handle the rest.
-        self._host_port_bindings = host_port_bindings
-
-    def image_exists(self) -> bool:
-        return run_docker(["docker", "image", "inspect", self.image_ref]).returncode == 0
-
-    def ensure_built(self) -> None:
-        """Build the bundle image from its Dockerfile, **cache-aware** — cheap
-        (a cache check) when nothing changed, a real rebuild when the flat
-        sources (egress addon / git-http / policy_resolver / supervise) moved.
-
-        This deliberately builds every time rather than build-if-missing: the
-        per-bottle model kept the image fresh via compose's `build:` on up, and
-        a stale image silently runs the OLD single-tenant daemons. No-op only
-        when no dockerfile is configured (a pre-pulled image). BOT_BOTTLE_NO_CACHE
-        forces a full rebuild (parity with `start --no-cache`)."""
-        if self._dockerfile is None:
-            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}",
-            # Share the one host DB: the supervise daemon queues proposals
-            # into the same file the orchestrator (and the operator, over
-            # HTTP) reads — no second, disconnected DB in the container.
-            "--volume", f"{_host_db_dir()}:{_SUPERVISE_DB_DIR_IN_CONTAINER}",
-            "--env", f"SUPERVISE_DB_PATH={DB_PATH_IN_CONTAINER}",
-        ]
-        for port in self._host_port_bindings:
-            argv += ["--publish", f"0.0.0.0:{port}:{port}"]
-        if self._orchestrator_url:
-            # Makes the gateway's egress / git / supervise daemons multi-tenant:
-            # each request resolves source-IP -> policy against the control plane.
-            argv += ["--env", f"BOT_BOTTLE_ORCHESTRATOR_URL={self._orchestrator_url}"]
-        argv.append(self.image_ref)
-        proc = run_docker(argv)
-        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,261 +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 os
-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, GatewayError
-
-DEFAULT_PORT = 8099
-ORCHESTRATOR_NAME = "bot-bottle-orchestrator"
-ORCHESTRATOR_LABEL = "bot-bottle-orchestrator=1"
-# The control-plane's own runtime image — lean (python + the stdlib-only
-# `bot_bottle` package, bind-mounted at run time), distinct from the heavy
-# gateway data-plane image it used to borrow (#384). Env override for
-# operators pinning a published build.
-ORCHESTRATOR_IMAGE = os.environ.get(
-    "BOT_BOTTLE_ORCHESTRATOR_IMAGE", "bot-bottle-orchestrator:latest"
-)
-ORCHESTRATOR_DOCKERFILE = "Dockerfile.orchestrator"
-# 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 lean orchestrator 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`.
-
-    `orchestrator_name` / `orchestrator_label` let backends run independent
-    orchestrators on the same host without name collisions (e.g. the
-    Firecracker backend uses `bot-bottle-fc-orchestrator` alongside the Docker
-    backend's `bot-bottle-orchestrator`). Subclass and override `_gateway()`
-    to supply a backend-specific gateway variant."""
-
-    def __init__(
-        self,
-        *,
-        port: int = DEFAULT_PORT,
-        network: str = GATEWAY_NETWORK,
-        image: str = ORCHESTRATOR_IMAGE,
-        gateway_image: str = GATEWAY_IMAGE,
-        repo_root: Path = _REPO_ROOT,
-        host_root: Path | None = None,
-        orchestrator_name: str = ORCHESTRATOR_NAME,
-        orchestrator_label: str = ORCHESTRATOR_LABEL,
-    ) -> None:
-        self.port = port
-        self.network = network
-        # Two distinct images (#384): `image` is the lean control-plane
-        # runtime this container runs; `_gateway_image` is the heavy egress /
-        # git-gate / supervise data plane the gateway container runs. They
-        # were one conflated image before the split.
-        self.image = image
-        self._gateway_image = gateway_image
-        self._repo_root = repo_root
-        self._host_root = host_root or bot_bottle_root()
-        self._orchestrator_name = orchestrator_name
-        self._orchestrator_label = orchestrator_label
-
-    @property
-    def url(self) -> str:
-        """Host-side control-plane URL (published loopback port)."""
-        return f"http://127.0.0.1:{self.port}"
-
-    @property
-    def internal_url(self) -> str:
-        """Control-plane URL as the gateway container reaches it — by name over
-        docker DNS on the shared network. This is the gateway's
-        BOT_BOTTLE_ORCHESTRATOR_URL."""
-        return f"http://{self._orchestrator_name}:{self.port}"
-
-    def is_healthy(self, *, timeout: float = _HEALTH_REQUEST_TIMEOUT_SECONDS) -> bool:
-        try:
-            with urllib.request.urlopen(f"{self.url}/health", timeout=timeout) as resp:
-                return resp.status == 200
-        except (urllib.error.URLError, TimeoutError, OSError):
-            return False
-
-    def _container_running(self, name: str) -> bool:
-        proc = run_docker(["docker", "ps", "--filter", f"name=^/{name}$", "--format", "{{.Names}}"])
-        return name in proc.stdout.split()
-
-    def _run_orchestrator_container(self, 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", self._orchestrator_name])
-        proc = run_docker([
-            "docker", "run", "--detach",
-            "--name", self._orchestrator_name,
-            "--label", self._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._gateway_image, network=self.network, orchestrator_url=self.internal_url
-        )
-
-    def _ensure_orchestrator_image(self) -> None:
-        """Build the lean control-plane image from `Dockerfile.orchestrator`
-        when it's missing (#384). Cheap — a `FROM python:*-slim` base with no
-        deps to install, so the layer cache makes rebuilds a no-op. Unlike the
-        gateway image this is build-if-missing, not build-every-time: the
-        control plane bind-mounts its source, so a code change is caught by the
-        source-hash recreate (below), not by an image rebuild."""
-        if run_docker(["docker", "image", "inspect", self.image]).returncode == 0:
-            return
-        argv = ["docker", "build", "-t", self.image,
-                "-f", str(self._repo_root / ORCHESTRATOR_DOCKERFILE),
-                str(self._repo_root)]
-        if os.environ.get("BOT_BOTTLE_NO_CACHE"):
-            argv.insert(2, "--no-cache")
-        proc = run_docker(argv)
-        if proc.returncode != 0:
-            raise GatewayError(
-                f"orchestrator image build failed: {proc.stderr.strip()}"
-            )
-
-    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(self._orchestrator_name):
-            return False
-        proc = run_docker([
-            "docker", "inspect", "--format",
-            "{{ index .Config.Labels \"" + ORCHESTRATOR_SOURCE_HASH_LABEL + "\" }}",
-            self._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
-
-        self._ensure_orchestrator_image()
-        log.info(
-            "starting orchestrator container",
-            context={"name": self._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", self._orchestrator_name])
-        self._gateway().stop()
-
-
-__all__ = [
-    "OrchestratorService",
-    "OrchestratorStartError",
-    "ORCHESTRATOR_NAME",
-    "ORCHESTRATOR_IMAGE",
-    "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 daemon 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

@@ -67,9 +67,9 @@ class BottleRecord:
     # Opaque JSON blob for forward-compat (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 /
+    # The bottle's sidecar 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.
+    # source IP; the multi-tenant sidecar interprets it.
     policy: str = ""
 
     def redacted(self) -> dict[str, object]:
@@ -102,9 +102,9 @@ _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
+        # v3 — per-bottle policy (opaque JSON the sidecar interprets): the
         # egress allowlist / routes / git config selected by source IP. The
-        # multi-tenant gateway resolves it per request via `attribute`.
+        # multi-tenant sidecar resolves it per request via `attribute`.
         "ALTER TABLE orchestrator_bottles ADD COLUMN policy TEXT NOT NULL DEFAULT ''",
     ],
 )
@@ -149,15 +149,7 @@ class RegistryStore(DbStore):
         policy: str = "",
     ) -> BottleRecord:
         """Register (or replace) a bottle. Mints a bottle_id / identity token
-        when not supplied. Live — this is the control-plane reload path.
+        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)."""
         rec = BottleRecord(
             bottle_id=bottle_id or secrets.token_hex(8),
             source_ip=source_ip,
@@ -168,11 +160,6 @@ class RegistryStore(DbStore):
             policy=policy,
         )
         with self._connect() as conn:
-            conn.execute(
-                "DELETE FROM orchestrator_bottles "
-                "WHERE source_ip = ? AND state = 'active' AND bottle_id != ?",
-                (rec.source_ip, rec.bottle_id),
-            )
             conn.execute(
                 "INSERT OR REPLACE INTO orchestrator_bottles "
                 "(bottle_id, source_ip, identity_token, state, created_at, metadata, policy) "
@@ -230,7 +217,7 @@ class RegistryStore(DbStore):
         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
+        plane is reachable only by the trusted sidecar; pair with the
         identity token (`attribute`) elsewhere."""
         with self._connect() as conn:
             rows = conn.execute(

bot_bottle/orchestrator/service.py

@@ -17,42 +17,14 @@ Launch lifecycle:
 
 from __future__ import annotations
 
-import json
-from datetime import datetime, timezone
-
 from .broker import LaunchBroker, LaunchRequest, sign_request
 from .registry import BottleRecord, RegistryStore
-from .gateway import Gateway
+from .sidecar import Sidecar
-from ..supervise import (
-    AuditEntry,
-    COMPONENT_FOR_TOOL,
-    Response,
-    STATUS_APPROVED,
-    STATUS_MODIFIED,
-    STATUS_REJECTED,
-    TOOL_EGRESS_ALLOW,
-    TOOL_EGRESS_BLOCK,
-    list_all_pending_proposals,
-    read_proposal,
-    render_diff,
-    write_audit_entry,
-    write_response,
-)
-
-
-# Operator decision → Response.status. The apply half (egress tools) runs
-# for approve/modify only.
-_RESPOND_STATUS = {
-    "approve": STATUS_APPROVED,
-    "modify": STATUS_MODIFIED,
-    "reject": STATUS_REJECTED,
-}
-_APPLY_TOOLS = (TOOL_EGRESS_ALLOW, TOOL_EGRESS_BLOCK)
 
 
 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__(
@@ -60,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
+        self._sidecar = sidecar
-        # Per-bottle egress auth tokens (env_name -> value), keyed by bottle_id.
-        # Held **in memory only** — never written to the registry DB — so the
-        # gateway can inject each bottle's upstream credential without secrets
-        # at rest. Lost on restart (re-launch re-registers them); the future
-        # SecretProvider (#355) replaces this with per-request minting.
-        self._tokens: dict[str, dict[str, str]] = {}
 
     def launch_bottle(
         self,
@@ -81,14 +47,11 @@ class Orchestrator:
         slot: int | None = None,
         metadata: str = "",
         policy: str = "",
-        tokens: dict[str, str] | None = None,
     ) -> BottleRecord:
-        """Register a bottle (with its gateway policy + in-memory egress auth
+        """Register a bottle (with its sidecar policy) and broker its launch.
-        tokens) and broker its launch. Rolls the registry entry back if the
+        Rolls the registry entry back if the launch doesn't take, so a
-        launch doesn't take, so a failure leaves no orphan."""
+        failure leaves no orphan."""
         rec = self.registry.register(source_ip, metadata=metadata, policy=policy)
-        if tokens:
-            self._tokens[rec.bottle_id] = dict(tokens)
         req = LaunchRequest(
             op="launch",
             bottle_id=rec.bottle_id,
@@ -103,7 +66,6 @@ class Orchestrator:
         finally:
             if not launched:
                 self.registry.deregister(rec.bottle_id)
-                self._tokens.pop(rec.bottle_id, None)
         return rec
 
     def teardown_bottle(self, bottle_id: str) -> bool:
@@ -114,164 +76,45 @@ 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:
+    def resolve(self, source_ip: str, identity_token: str = "") -> BottleRecord | None:
-        """Resolve the bottle behind a request — the per-request lookup the
+        """Resolve the bottle behind a request — the source-IP-keyed lookup
-        multi-tenant gateway makes; the returned record carries its `policy`.
+        the multi-tenant sidecar makes per request; the returned record
-
+        carries its `policy`. With a token, full attribution (source IP +
-        **Mandatory pair**: requires a matching `(source_ip, identity_token)`
+        token); without, network-layer attribution by source IP alone
-        (constant-time). There is no source-IP-only fallback — the app-layer
+        (valid where the IP is unspoofable and the control plane is
-        token is delivered on every attributed data plane (egress proxy
+        sidecar-only)."""
-        credentials, git-gate/supervise headers), so a missing or mismatched
+        if identity_token:
-        token fail-closes. This keeps a spoofed source IP (which the /31 TAP
-        alone does not prevent) from selecting another bottle's policy/tokens
-        without also holding that bottle's unguessable token."""
             return self.registry.attribute(source_ip, identity_token)
+        return self.registry.by_source_ip(source_ip)
 
     def set_policy(self, bottle_id: str, policy: str) -> bool:
-        """Update a bottle's gateway policy in place (live reload). False if
+        """Update a bottle's sidecar policy in place (live reload). False if
         the bottle is unknown."""
         return self.registry.set_policy(bottle_id, policy)
 
-    # --- supervise queue (operator approvals) ------------------------------
+    # --- consolidated sidecar ----------------------------------------------
-    #
-    # The orchestrator owns the single DB *and* the live policy, so operator
-    # decisions are applied here, server-side, and reached over HTTP by the
-    # host TUI (no direct-DB access, one path for every backend).
 
-    def supervise_pending(self) -> list[dict[str, object]]:
+    def ensure_sidecar(self) -> None:
-        """All pending proposals across bottles, FIFO, as JSON dicts
+        """Ensure the single per-host sidecar is built and up (idempotent).
-        (`Proposal.to_dict`, round-trippable via `Proposal.from_dict`).
+        No-op when no sidecar is configured."""
+        if self._sidecar is not None:
+            self._sidecar.ensure_built()
+            self._sidecar.ensure_running()
 
-        Each dict carries an extra `bottle_label`: the bottle's human slug
+    def sidecar_status(self) -> dict[str, object]:
-        resolved from the registry (the proposal itself is keyed by the
+        """Report the shared sidecar for the control plane / console."""
-        orchestrator-assigned bottle_id, which is opaque to an operator). The
+        if self._sidecar is None:
-        CLI renders the label but still responds against `bottle_slug`."""
-        out: list[dict[str, object]] = []
-        for p in list_all_pending_proposals():
-            d = p.to_dict()
-            d["bottle_label"] = self._label_for(p.bottle_slug)
-            out.append(d)
-        return out
-
-    def _label_for(self, bottle_slug: str) -> str:
-        """The human slug recorded in registry metadata for a proposal's
-        bottle, or the bottle_slug unchanged when the bottle is gone or has no
-        recorded slug — so the label is always non-empty."""
-        rec = self.registry.get(bottle_slug)
-        if rec is None:
-            return bottle_slug
-        try:
-            meta = json.loads(rec.metadata) if rec.metadata else {}
-        except ValueError:
-            meta = {}
-        slug = meta.get("slug") if isinstance(meta, dict) else None
-        return slug if isinstance(slug, str) and slug else bottle_slug
-
-    def _record_for_slug(self, slug: str) -> BottleRecord | None:
-        """The live registry record for a proposal's bottle, or None (e.g. the
-        bottle was torn down before the operator responded).
-
-        In consolidated mode the supervise server attributes each proposal to
-        the orchestrator-assigned bottle_id and stores that as the proposal's
-        `bottle_slug` (see supervise_server `_attributed_config`), so the fast
-        path is a direct bottle_id lookup. The metadata-slug scan is the
-        fallback for legacy single-tenant proposals keyed by the human slug."""
-        rec = self.registry.get(slug)
-        if rec is not None:
-            return rec
-        for rec in self.registry.all():
-            try:
-                meta = json.loads(rec.metadata) if rec.metadata else {}
-            except ValueError:
-                meta = {}
-            if isinstance(meta, dict) and meta.get("slug") == slug:
-                return rec
-        return None
-
-    def supervise_respond(
-        self,
-        proposal_id: str,
-        *,
-        bottle_slug: str,
-        decision: str,
-        notes: str = "",
-        final_file: str | None = None,
-    ) -> tuple[bool, str]:
-        """Record an operator decision on a queued proposal, applying it
-        server-side. `decision` is approve/modify/reject.
-
-        Approve/modify on an egress tool rewrites the bottle's policy so the
-        gateway serves the new routes on its next `/resolve` (the live apply);
-        then the queued Response is written (unblocking the agent's MCP call)
-        and an audit entry recorded — all against the one DB. Returns
-        (ok, error): ok=False with a message when the proposal or decision is
-        unknown, or the bottle is gone so an approval can't be applied."""
-        status = _RESPOND_STATUS.get(decision)
-        if status is None:
-            return False, f"unknown decision {decision!r}"
-        try:
-            proposal = read_proposal(bottle_slug, proposal_id)
-        except FileNotFoundError:
-            return False, "no such proposal"
-
-        diff_before, diff_after = "", ""
-        if status in (STATUS_APPROVED, STATUS_MODIFIED) and proposal.tool in _APPLY_TOOLS:
-            new_policy = final_file if final_file is not None else proposal.proposed_file
-            rec = self._record_for_slug(bottle_slug)
-            if rec is None:
-                return False, (
-                    f"bottle {bottle_slug!r} is no longer registered; "
-                    "cannot apply the route change"
-                )
-            diff_before, diff_after = rec.policy, new_policy
-            self.set_policy(rec.bottle_id, new_policy)
-
-        write_response(bottle_slug, Response(
-            proposal_id=proposal_id, status=status, notes=notes, final_file=final_file,
-        ))
-        component = COMPONENT_FOR_TOOL.get(proposal.tool)
-        if component is not None:
-            write_audit_entry(AuditEntry(
-                timestamp=datetime.now(timezone.utc).isoformat(),
-                bottle_slug=bottle_slug,
-                component=component,
-                operator_action=status,
-                operator_notes=notes,
-                justification=proposal.justification,
-                diff=render_diff(diff_before, diff_after, label=component),
-            ))
-        return True, ""
-
-    # --- 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:
             return {"configured": False}
         return {
             "configured": True,
-            "name": self._gateway.name,
+            "name": self._sidecar.name,
-            "running": self._gateway.is_running(),
+            "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/paths.py

@@ -10,7 +10,7 @@ suite points it at a throwaway dir instead of monkey-patching the function
 override covers them all), and operators can relocate the root if needed.
 
 This module has no bot-bottle imports, so it is safe to import from any
-layer (and to COPY flat into the gateway).
+layer (and to COPY flat into the sidecar bundle).
 """
 
 from __future__ import annotations
@@ -35,7 +35,7 @@ def host_db_path() -> Path:
 
     Kept in its own `db/` subdirectory (not directly under the root) so a
     backend that can only bind-mount *directories* can share this one file
-    with a gateway without exposing the root's other contents (git-gate
+    with a sidecar without exposing the root's other contents (git-gate
     keys, per-bottle state, ...)."""
     return bot_bottle_root() / "db" / HOST_DB_FILENAME
 

bot_bottle/policy_resolver.py

@@ -1,6 +1,6 @@
-"""Gateway-side per-client policy resolver (PRD 0070).
+"""Sidecar-side per-client policy resolver (PRD 0070).
 
-The consolidated gateway serves every bottle from one process, so for each
+The consolidated sidecar 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
@@ -23,7 +23,7 @@ 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 gateway.
+the sidecar bundle.
 """
 
 from __future__ import annotations
@@ -47,11 +47,12 @@ class PolicyResolver:
         self._base = base_url.rstrip("/")
         self._timeout = timeout
 
-    def _post_resolve(self, source_ip: str, identity_token: str) -> dict[str, object] | None:
+    def resolve(self, source_ip: str, identity_token: str = "") -> str | None:
-        """The orchestrator's `/resolve` payload for this client, or None if
+        """The calling bottle's policy blob, or None if unattributed. Always
-        unattributed (a clean `403`). Raises `PolicyResolveError` on an
+        fetches from the orchestrator so revocations / changes / teardowns
-        unreachable / unexpected-status / malformed response so every caller
+        are honored immediately. `identity_token` is optional — omit it to
-        can fail closed. Shared by `resolve` and `resolve_bottle_id`."""
+        resolve by source IP alone (the network-layer attribution).
+        Raises `PolicyResolveError` if the orchestrator can't be reached."""
         body = json.dumps(
             {"source_ip": source_ip, "identity_token": identity_token}
         ).encode()
@@ -68,61 +69,8 @@ class PolicyResolver:
             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 {}
+        policy = payload.get("policy") if isinstance(payload, dict) else None
-
-    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/queue_store.py

@@ -26,7 +26,7 @@ class QueueStore(DbStore):
         if db_path is not None:
             resolved = db_path
         else:
-            # In the gateway container SUPERVISE_DB_PATH points at the
+            # In the sidecar container SUPERVISE_DB_PATH points at the
             # bind-mounted host DB. On the host this env var is never set,
             # so we always fall through to host_db_path().
             env_path = os.environ.get("SUPERVISE_DB_PATH", "").strip()

bot_bottle/sidecar_init.py

@@ -1,26 +1,26 @@
-"""Gateway data-plane supervisor (PRD 0070; PRD 0024 bundle shape).
+"""Per-bottle sidecar supervisor (PRD 0024 chunk 1).
 
-PID 1 inside the `bot-bottle-gateway` data-plane image. Spawns
+PID 1 inside the `bot-bottle-sidecars` bundle image. Spawns
 the configured daemons (egress, git-gate, supervise),
 forwards SIGTERM/SIGINT to each child, and propagates per-daemon
 stdout+stderr to the container log with a `[name] ` prefix.
 
 Failure policy (interim): when a child dies unexpectedly, the
 supervisor logs the death and leaves the surviving children
-running. The gateway stays up; whatever the dead daemon served
+running. The bundle stays up; whatever the dead daemon served
 will start failing, surfacing in the agent's own error path.
-The supervisor itself exits only when (a) the operator sends
+The supervisor itself exits only when (a) the operator/compose
-SIGTERM/SIGINT, or (b) every child has died.
+sends SIGTERM/SIGINT, or (b) every child has died.
 
 Failure policy (eventual): on unexpected death, the supervisor
 restarts the daemon and emits a notification to the supervise
-daemon so the operator sees the event. That lands in a later
+sidecar so the operator sees the event. That lands in a later
-PR; the interim policy is "don't take the gateway down for one
+PR; the interim policy is "don't take the bundle down for one
 sick daemon."
 
-Daemon subset is env-driven via `BOT_BOTTLE_GATEWAY_DAEMONS=egress`
+Daemon subset is env-driven. The compose renderer narrows it via
-for callers that don't use git-gate or supervise. Default: all
+`BOT_BOTTLE_SIDECAR_DAEMONS=egress` for bottles that
-daemons.
+don't use git-gate or supervise. Default: all daemons.
 
 Stdlib-only by design — adding supervisord/s6/runit for four
 daemons is heavier than this script.
@@ -103,8 +103,8 @@ def _selected_daemons(
     env: dict[str, str],
     all_daemons: Sequence[_DaemonSpec] | None = None,
 ) -> tuple[_DaemonSpec, ...]:
-    """Filter the daemon set by the BOT_BOTTLE_GATEWAY_DAEMONS env
+    """Filter the daemon set by the BOT_BOTTLE_SIDECAR_DAEMONS env
-    var. Unknown names in the list are ignored — the caller is the
+    var. Unknown names in the list are ignored — the renderer is the
     source of truth for which daemons are wired.
 
     `all_daemons` defaults to `_DAEMONS` resolved at call time (not
@@ -112,7 +112,7 @@ def _selected_daemons(
     `_DAEMONS` and have the new value take effect."""
     if all_daemons is None:
         all_daemons = _DAEMONS
-    raw = env.get("BOT_BOTTLE_GATEWAY_DAEMONS", "").strip()
+    raw = env.get("BOT_BOTTLE_SIDECAR_DAEMONS", "").strip()
     if not raw:
         return tuple(all_daemons)
     wanted = {n.strip() for n in raw.split(",") if n.strip()}
@@ -120,7 +120,7 @@ def _selected_daemons(
 
 
 def _log(msg: str) -> None:
-    sys.stdout.write(f"gateway-init: {msg}\n")
+    sys.stdout.write(f"sidecar-init: {msg}\n")
     sys.stdout.flush()
 
 

bot_bottle/supervise.py

@@ -1,25 +1,25 @@
 """Per-bottle supervise plane (PRD 0013).
 
-The supervise plane is the per-bottle MCP daemon plus its host-side
+The supervise plane is the per-bottle MCP sidecar plus its host-side
-queue/audit support. The daemon (bot_bottle.supervise_server)
+queue/audit support. The sidecar (bot_bottle.supervise_server)
 sits on the bottle's internal network and exposes MCP tools the agent
 calls when it needs an operator-reviewed egress change:
 
   * egress-block / allow — agent proposes a new routes.yaml
 
 Each tool call: the agent passes the full proposed file plus a
-justification text. The gateway validates the proposal syntactically,
+justification text. The sidecar validates the proposal syntactically,
 writes it to the host SQLite queue table, and holds the tool-call
 connection open. The operator's supervise TUI
 (bot_bottle.cli.supervise) sees the proposal, accepts
-approve / modify / reject, and writes a response row. The gateway sees
+approve / modify / reject, and writes a response row. The sidecar sees
 the response and returns `{status, notes}` to the agent.
 
 This module defines the host-side library: dataclasses for the queue
 record shapes, queue read/write helpers, the audit log writer, and the
-diff renderer. The in-gateway daemon lives in
+diff renderer. The in-container sidecar lives in
 bot_bottle/supervise_server.py; the supervise daemon's container
-lifecycle is owned by the gateway (PRD 0024).
+lifecycle is owned by the sidecar bundle (PRD 0024).
 
 For 0013 the supervisor's approval handlers are deliberately no-ops:
 on approval the audit log is written and the response file is
@@ -75,18 +75,18 @@ except ImportError:
 
 try:
     from .paths import bot_bottle_root
-except ImportError:  # flat imports inside the gateway
+except ImportError:  # flat imports inside the sidecar bundle
     from paths import bot_bottle_root  # type: ignore[import-not-found,no-redef]  # pylint: disable=import-error,no-name-in-module
 
 
 SUPERVISE_HOSTNAME = "supervise"
 SUPERVISE_PORT = 9100
 
-# The supervise daemon uses these to query egress's
+# The supervise sidecar uses these to query egress's
 # introspection endpoint for the `list-egress-routes` MCP
 # tool. The hostname + port match egress's docker network
 # listen port (see backend.docker.egress.EGRESS_PORT). The supervise
-# daemon runs inside the gateway alongside egress, so loopback
+# daemon runs inside the sidecar bundle alongside egress, so loopback
 # is the stable address across docker, firecracker, and Apple
 # Container backends.
 EGRESS_FORWARD_PROXY = "http://127.0.0.1:9099"
@@ -117,7 +117,7 @@ try:
     from .audit_store import AuditStore
     from .store_manager import StoreManager
 except ImportError:
-    # Gateway: files are flat-copied under /app, not a package.
+    # Sidecar bundle: files are flat-copied under /app, not a package.
     from queue_store import QueueStore  # type: ignore[import-not-found]  # pylint: disable=import-error,no-name-in-module
     from audit_store import AuditStore  # type: ignore[import-not-found]  # pylint: disable=import-error,no-name-in-module
     from store_manager import StoreManager  # type: ignore[import-not-found]  # pylint: disable=import-error,no-name-in-module
@@ -222,14 +222,14 @@ def sha256_hex(content: str) -> str:
     return hashlib.sha256(content.encode("utf-8")).hexdigest()
 
 
-# --- Gateway plan + abstract lifecycle -------------------------------------
+# --- Sidecar plan + abstract lifecycle -------------------------------------
 
 
 @dataclass(frozen=True)
 class SupervisePlan:
     """Output of Supervise.prepare; consumed by .start.
 
-    `db_path` is the host database bind-mounted into the gateway at
+    `db_path` is the host database bind-mounted into the sidecar at
     /run/supervise/bot-bottle.db. `internal_network` is empty at
     prepare time; the backend's launch step fills it via
     dataclasses.replace before calling .start."""
@@ -240,8 +240,8 @@ class SupervisePlan:
 
 
 class Supervise(ABC):
-    """Per-bottle supervise daemon. Encapsulates host-side database
+    """Per-bottle supervise sidecar. Encapsulates host-side database
-    staging; the gateway's start/stop lifecycle is backend-specific."""
+    staging; the sidecar's start/stop lifecycle is backend-specific."""
 
     def prepare(
         self,

bot_bottle/supervise_server.py

@@ -1,4 +1,4 @@
-"""Supervise daemon HTTP server (PRD 0013).
+"""Supervise sidecar HTTP server (PRD 0013).
 
 Per-bottle MCP server exposing tools the agent calls to propose egress
 config changes when stuck. The tools are `egress-allow`,
@@ -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,22 +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.gateway.
+    # COPYed flat under /app by Dockerfile.sidecars.
-    from egress_addon_core import (
+    from egress_addon_core import LOG_OFF, load_config
-        LOG_OFF, load_config, resolve_client_context, route_to_yaml_dict,
-    )
-    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 (
+    from .egress_addon_core import LOG_OFF, load_config
-        LOG_OFF, load_config, resolve_client_context, route_to_yaml_dict,
-    )
-    from .policy_resolver import PolicyResolveError, PolicyResolver
     from . import supervise as _sv
 
 
@@ -69,8 +57,6 @@ except ModuleNotFoundError:
 
 
 MCP_PROTOCOL_VERSION = "2024-11-05"
-# App-layer identity token header (mirrors egress_addon / git_http_backend).
-IDENTITY_HEADER = "x-bot-bottle-identity"
 SERVER_NAME = "bot-bottle-supervise"
 SERVER_VERSION = "0.1.0"
 
@@ -87,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:
@@ -531,68 +511,9 @@ class MCPHandler(http.server.BaseHTTPRequestHandler):
         if method == "tools/list":
             return handle_tools_list(req.params)
         if method == "tools/call":
-            # `list-egress-routes` is read-only introspection. In consolidated
+            return handle_tools_call(req.params, config)
-            # mode the gateway's *static* route table is empty (routes are
-            # resolved per request by source IP), so answer it from the calling
-            # bottle's resolved policy. Otherwise the agent sees an empty
-            # allowlist and composes an egress proposal that *replaces* the live
-            # routes instead of extending them — silently dropping base routes
-            # like api.anthropic.com when the operator approves it.
-            if req.params.get("name") == _sv.TOOL_LIST_EGRESS_ROUTES:
-                resolved = self._resolved_routes_payload()
-                if resolved is not None:
-                    return resolved
-            # 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))
         raise _RpcClientError(ERR_METHOD_NOT_FOUND, f"method not found: {method}")
 
-    def _resolved_routes_payload(self) -> dict[str, object] | None:
-        """The calling bottle's live egress routes as the `list-egress-routes`
-        JSON payload, resolved by (source_ip, identity token) — the same shape
-        the single-tenant introspection endpoint returns. None when there is no
-        resolver (single-tenant), so the caller falls back to that endpoint.
-
-        Fail-closed like `_attributed_config`: an unattributed source or an
-        unreachable orchestrator yields an empty route list (never another
-        bottle's), courtesy of `resolve_client_context`."""
-        resolver = getattr(self.server, "policy_resolver", None)
-        if resolver is None:
-            return None
-        headers = getattr(self, "headers", None)
-        token = headers.get(IDENTITY_HEADER, "") if headers is not None else ""
-        conf, _slug, _tokens = resolve_client_context(
-            resolver, self.client_address[0], token,
-        )
-        body = json.dumps(
-            {"routes": [route_to_yaml_dict(r) for r in conf.routes]}, indent=2,
-        )
-        return {"content": [{"type": "text", "text": body}], "isError": False}
-
-    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
-        # The agent's MCP client sends the identity token as a request header
-        # (provisioned via `mcp add --header`); the orchestrator requires the
-        # (source_ip, token) pair, so a missing/wrong token fail-closes below.
-        headers = getattr(self, "headers", None)
-        token = headers.get(IDENTITY_HEADER, "") if headers is not None else ""
-        try:
-            bottle_id = resolver.resolve_bottle_id(self.client_address[0], token)
-        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")
@@ -616,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 -----------------------------------------------------------
@@ -630,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()
@@ -655,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
+    if not bottle_slug:
-    # optional there; single-tenant still requires it.
-    if not bottle_slug and resolver is None:
         sys.stderr.write("supervise: SUPERVISE_BOTTLE_SLUG env is unset\n")
         return 2
     port = int(os.environ.get("SUPERVISE_PORT", str(_sv.SUPERVISE_PORT)))
@@ -675,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
 

bot_bottle/yaml_subset.py

@@ -71,7 +71,7 @@ class YamlSubsetError(ValueError):
     that want fatal-exit semantics (manifest loader, egress-apply,
     etc.) catch this at their own boundary and forward to `die`;
     callers running outside the bot-bottle CLI process (the
-    egress daemon's addon) handle it as a normal exception."""
+    egress sidecar's addon) handle it as a normal exception."""
 
 
 

docs/ci.md

@@ -22,7 +22,8 @@ mounted in. That topology breaks two assumptions those tests make:
   `http://127.0.0.1:<host_port>` from inside the job time out.
 
 The affected tests (`test_orphan_cleanup.test_create_and_remove`,
-`test_gateway_image.TestGatewayImage`) still run
+`test_sidecar_bundle_image.TestSidecarBundleImage`,
+`test_sidecar_bundle_compose.TestSidecarBundleCompose`) still run
 locally where the test process and Docker daemon share a host.
 Making them work in CI is a follow-up: either re-write them to
 discover container IPs via `docker inspect`, or reconfigure the

docs/demo.tape

@@ -38,7 +38,7 @@ Type "y"
 Enter
 
 # Wait for the bottle to launch: networks created, pipelock + git-gate
-# companion containers started, agent container started, claude boots.
+# sidecars started, agent container started, claude boots.
 Sleep 22s
 
 # Probe 1 — warm-up. A reply at all proves api.anthropic.com is
@@ -72,7 +72,7 @@ Type "init /tmp/r, commit AKIAQRJHK7N5ZPM2VXTL to leak.txt, push to ssh://git@up
 Enter
 Sleep 30s
 
-# Leave claude. The launcher tears down the container, companion containers, and
+# Leave claude. The launcher tears down the container, sidecars, and
 # networks on session end.
 Ctrl+D
 Sleep 4s

docs/prds/0069-firecracker-native-docker-free.md

@@ -8,20 +8,16 @@
 > **Superseded in part by [PRD 0070](0070-per-host-orchestrator.md) (#351):**
 > the sidecar-consolidation framing here (Stage 1, per-host sidecar; Stage 4,
 > sidecar-as-VM) is taken over by 0070's per-host orchestrator. This PRD still
-> owns the docker-free **image-provisioning** work — Stage 2 (pull the fixed
+> owns the docker-free **image-building** work — Stage 2 (nix-built fixed
-> images from an OCI registry instead of building them with host Docker, a
+> images, a dependency of 0070) and Stage 3 (in-VM Dockerfile builder).
-> dependency of 0070) and Stage 3 (in-VM Dockerfile builder).
 
 ## Summary
 
 Make the Firecracker backend depend on **firecracker + KVM only**, removing
 Docker from the host. Two moves get us there: run the **sidecar bundle as a
 persistent, per-host service** (eventually a Firecracker VM) instead of a
-per-bottle container, and **provision rootfs images without a host Docker
+per-bottle container, and **build agent rootfs images without a host Docker
-daemon** — pull the fixed images (orchestrator/gateway/infra) from an OCI
+daemon** (nix for the fixed images; an in-VM builder for user Dockerfiles).
-registry and unpack them daemonlessly, and build user Dockerfiles in an in-VM
-builder. The images are still *built* with Docker, but off the launch host
-(CI / a publish step) and pushed to the registry; the launch host only pulls.
 
 ## Motivation
 
@@ -97,51 +93,13 @@ torn down at exit."
 Can ship as a container first (quick resource/ops win) and become a VM in
 Stage 4.
 
-### Stage 2 — Fixed rootfs prebuilt + pulled as an artifact (no host Docker)
+### Stage 2 — Fixed images built with nix (no Docker)
 
-The one fixed image the Firecracker backend needs at launch — the combined
+The images bot-bottle *ships* — the sidecar, the agent base, and the builder
-**infra** rootfs the infra VM boots (orchestrator control plane + gateway +
+(Stage 3) — are built declaratively with nix (`nixos-generators` /
-buildah, with the control-plane init as PID 1) — is **prebuilt end-to-end off
+`make-ext4-fs` / `pkgs.dockerTools` for the rootfs), producing an ext4 or
-the launch host and published as a versioned, ready-to-boot ext4 artifact**.
+tar with correct ownership. Removes Docker for everything we own and gives
-The launch host **downloads the `.ext4` and boots it directly** — no
+the rootless-rootfs correctness (#347) for free on these images.
-`docker build`, no `docker export`, no `mke2fs`, no image tooling at all.
-
-This is possible because the infra rootfs is already **host- and
-bottle-agnostic**: the per-boot bits (authorized_keys, guest IP) arrive on the
-**kernel cmdline**, not in the rootfs (see `build_base_rootfs_dir`). So one
-published ext4 boots on any launch host.
-
-- **Artifact.** `rootfs.ext4` + a `rootfs.ext4.sha256`, published as a Gitea
-  **generic package** (`bot-bottle-firecracker-infra/<tag>`) — generic packages take
-  arbitrary large binaries (no attachment size cap / file-type allowlist that
-  release attachments impose). The matching `vmlinux` kernel can ship the same
-  way, so the whole VM is fetchable.
-- **Pull.** The launch host `GET`s
-  `…/api/packages/<owner>/generic/bot-bottle-firecracker-infra/<tag>/rootfs.ext4` (+
-  `.sha256`) for its pinned tag, verifies the checksum, caches it under the
-  tag, and attaches it as the infra VM's root disk. Host prerequisite is an
-  HTTP client — nothing else. Public packages need no auth to pull; a token
-  with `read:package` covers a private instance.
-- **Registry.** The artifact base URL + owner are configurable, defaulting to
-  this deployment's Gitea (`https://gitea.dideric.is` / `didericis`);
-  overridable via env for other deployments / air-gapped mirrors.
-- **Versioning.** A pinned tag bumped when the infra rootfs contents change
-  (bot_bottle's shipped files, the base deps, or the init), so a launch host
-  pulls the artifact matching its code and a content change can't silently
-  boot a stale rootfs. A checksum mismatch fails closed.
-- **Publish.** A `publish` step (CLI subcommand / CI job) runs the full
-  pipeline **on a build/CI host** — `docker build` the three Dockerfiles →
-  export → inject guest boot → `mke2fs` → upload the `.ext4` + `.sha256`.
-  Building still uses Docker, but never on the launch/runner host, which is
-  the one #348 needs unprivileged.
-- **Dev escape hatch.** An explicit opt-in still builds the rootfs locally
-  with Docker (for iterating on the Dockerfiles without a publish
-  round-trip); it is never the default path.
-
-Removes Docker from the launch host entirely for the fixed image, and the
-launch host needs no OCI/rootfs tooling — just fetch + boot. The build-time
-cache / build-time-egress open problems a from-scratch build would face don't
-arise: the launch host never builds, it downloads a finished disk.
 
 ### Stage 3 — User Dockerfiles built in a builder VM (the unlock)
 

docs/prds/0070-per-host-orchestrator.md

@@ -10,8 +10,8 @@
 
 ## Summary
 
-Replace the **per-bottle gateway bundle** with a single **persistent,
+Replace the **per-bottle sidecar bundle** with a single **persistent,
-per-host orchestrator**: one long-lived service that runs the gateway
+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.
+  sidecars, a control path baked at launch and torn down at exit.
-- **A blurry contract.** "How a bottle talks to its gateway" is
+- **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
+**Today's wiring** (`bot_bottle/cli/start.py`): the host's
-Status note in the Summary; the token now lives in the egress sidecar
-and the agent gets a placeholder): 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:

nix/firecracker-netpool.nix

@@ -2,7 +2,7 @@
 #
 # The one-time privileged setup the Firecracker backend needs: a pool of
 # user- (or group-) owned point-to-point TAP devices plus a fail-closed
-# nftables table that confines every microVM to its own gateway.
+# nftables table that confines every microVM to its own sidecar.
 #
 # NON-INVASIVE BY DESIGN. It does NOT flip `networking.nftables.enable`
 # (which would switch your whole host firewall backend) or
@@ -49,12 +49,10 @@ let
   # /31 alignment == an even final octet (only bit 0 matters for base+2i).
   lastOctet = lib.toInt (lib.last (lib.splitString "." cfg.ipBase));
 
-  # The script needs ip/nft/sysctl + the usual coreutils, plus iptables
+  # The script needs ip/nft/sysctl + the usual coreutils. It gets every
-  # for the orchestrator link's DOCKER-USER accept (best-effort; skipped
+  # pool value via the unit's Environment=, so it never reads the shared
-  # when Docker is absent). It gets every pool value via the unit's
+  # defaults file (which isn't beside it once copied to the store).
-  # Environment=, so it never reads the shared defaults file (which isn't
+  runtimePath = with pkgs; [ iproute2 nftables procps coreutils gnused ];
-  # beside it once copied to the store).
-  runtimePath = with pkgs; [ iproute2 nftables iptables procps coreutils gnused ];
 
   ownEnv =
     if cfg.group != null
@@ -66,7 +64,6 @@ let
     BOT_BOTTLE_FC_IP_BASE = cfg.ipBase;
     BOT_BOTTLE_FC_IFACE_PREFIX = cfg.ifacePrefix;
     BOT_BOTTLE_FC_NFT_TABLE = cfg.tableName;
-    BOT_BOTTLE_FC_ORCH_IFACE = cfg.orchIface;
   } // ownEnv;
 in
 {
@@ -130,19 +127,6 @@ in
       description = "nftables table name for the isolation boundary. Must match netpool.NFT_TABLE.";
     };
 
-    orchIface = lib.mkOption {
-      type = lib.types.str;
-      default = defaults.BOT_BOTTLE_FC_ORCH_IFACE;
-      defaultText = lib.literalMD "the shared `netpool.defaults.env` value";
-      description = ''
-        TAP name for the orchestrator/gateway VM's dedicated link. Unlike
-        the isolated bbfc* agent pool, this link is NAT'd to the internet
-        (the orchestrator is trusted infra that builds agent images in-VM
-        and forwards agent egress upstream). Must match
-        BOT_BOTTLE_FC_ORCH_IFACE / netpool.ORCH_IFACE.
-      '';
-    };
-
     writeEnvFile = lib.mkOption {
       type = lib.types.bool;
       default = false;
@@ -166,7 +150,7 @@ in
       }
     ];
 
-    # VM->gateway traffic is DNAT'd and forwarded, so forwarding must be on.
+    # VM->sidecar traffic is DNAT'd and forwarded, so forwarding must be on.
     boot.kernel.sysctl."net.ipv4.ip_forward" = 1;
 
     # One oneshot brings up the whole pool (TAPs + independent nft table)
@@ -192,7 +176,6 @@ in
         BOT_BOTTLE_FC_IP_BASE=${cfg.ipBase}
         BOT_BOTTLE_FC_IFACE_PREFIX=${cfg.ifacePrefix}
         BOT_BOTTLE_FC_NFT_TABLE=${cfg.tableName}
-        BOT_BOTTLE_FC_ORCH_IFACE=${cfg.orchIface}
       '';
     };
   };

scripts/firecracker-netpool.sh

@@ -4,7 +4,7 @@
 # Creates a pool of point-to-point TAP devices (owned by the invoking
 # user so the backend can open them without root at launch) and a
 # dedicated nftables table that isolates every VM: a bottle VM can
-# reach only its own gateway (published on the host-side TAP IP) and
+# reach only its own sidecar (published on the host-side TAP IP) and
 # nothing else on the host or network.
 #
 # Why a pool + one-time setup: creating a TAP and assigning it an IP
@@ -63,19 +63,18 @@ POOL_SIZE="${BOT_BOTTLE_FC_POOL_SIZE:-$(_default BOT_BOTTLE_FC_POOL_SIZE)}"
 IP_BASE="${BOT_BOTTLE_FC_IP_BASE:-$(_default BOT_BOTTLE_FC_IP_BASE)}"
 PREFIX="${BOT_BOTTLE_FC_IFACE_PREFIX:-$(_default BOT_BOTTLE_FC_IFACE_PREFIX)}"
 TABLE="${BOT_BOTTLE_FC_NFT_TABLE:-$(_default BOT_BOTTLE_FC_NFT_TABLE)}"
-ORCH_IFACE="${BOT_BOTTLE_FC_ORCH_IFACE:-$(_default BOT_BOTTLE_FC_ORCH_IFACE)}"
 OWNER="${BOT_BOTTLE_FC_OWNER:-${SUDO_USER:-$USER}}"
 GROUP="${BOT_BOTTLE_FC_GROUP:-}"
 
 # Fail loudly rather than provisioning a half/empty range if a value
 # resolved to nothing (env unset AND the shared file unreadable).
-for _v in POOL_SIZE IP_BASE PREFIX TABLE ORCH_IFACE; do
+for _v in POOL_SIZE IP_BASE PREFIX TABLE; do
     [ -n "${!_v}" ] || { echo "error: $_v unresolved (set BOT_BOTTLE_FC_* or fix $_DEFAULTS)" >&2; exit 1; }
 done
 
-# Gateway ports (must match the backend). egress=9099, supervise=9100,
+# Sidecar ports (must match the backend). egress=9099, supervise=9100,
 # git-http=9420. Reached by the VM at its host-side TAP IP.
-GATEWAY_PORTS="9099,9100,9420"
+SIDECAR_PORTS="9099,9100,9420"
 
 # --- IP math ---------------------------------------------------------
 # Slot i occupies the /31 {base+2i, base+2i+1}: host = base+2i (the
@@ -90,13 +89,6 @@ host_ip() { _int_to_ip $(( $(_ip_to_int "$IP_BASE") + 2*$1 )); }
 guest_ip() { _int_to_ip $(( $(_ip_to_int "$IP_BASE") + 2*$1 + 1 )); }
 iface()   { echo "${PREFIX}$1"; }
 
-# Orchestrator/gateway VM link: a /31 at the TOP of the IP_BASE /16
-# (host x.y.255.0, guest x.y.255.1), well clear of the agent pool near
-# the bottom of the block. Must match netpool.py:orch_slot().
-_orch_base() { echo $(( ($(_ip_to_int "$IP_BASE") & 0xFFFF0000) + 0xFF00 )); }
-orch_host()  { _int_to_ip "$(_orch_base)"; }
-orch_guest() { _int_to_ip $(( $(_orch_base) + 1 )); }
-
 require_root() {
     if [ "$(id -u)" -ne 0 ]; then
         echo "error: '$1' needs root (run under sudo)" >&2
@@ -115,7 +107,7 @@ cmd_up() {
     fi
     echo "firecracker net pool: $POOL_SIZE slots, base $IP_BASE, $own_desc"
 
-    # VM->gateway traffic is DNAT'd to the gateway container and
+    # VM->sidecar traffic is DNAT'd to the sidecar container and
     # forwarded, so forwarding must be enabled (Docker also sets this).
     sysctl -qw net.ipv4.ip_forward=1
 
@@ -133,21 +125,8 @@ cmd_up() {
         echo "  $dev  host=$host  guest=$(guest_ip "$i")  $own_desc"
     done
 
-    # The orchestrator/gateway VM's dedicated link. Same rootless-open
-    # ownership as the pool, but NAT'd to the internet (below) — it is
-    # trusted infra, not an isolated agent slot.
-    ip link show "$ORCH_IFACE" >/dev/null 2>&1 \
-        || ip tuntap add dev "$ORCH_IFACE" mode tap "${own_args[@]}"
-    ip addr replace "$(orch_host)/31" dev "$ORCH_IFACE"
-    ip link set "$ORCH_IFACE" up
-    echo "  $ORCH_IFACE  host=$(orch_host)  guest=$(orch_guest)  (NAT'd egress)  $own_desc"
-
     _install_nft
     echo "nftables table inet $TABLE installed (fail-closed boundary)"
-    _install_orch_egress
-    echo "orchestrator egress installed ($ORCH_IFACE -> NAT out)"
-    _install_gateway_route
-    echo "agent->gateway route installed (${PREFIX}* :$GATEWAY_PORTS -> $(orch_guest))"
     echo "done."
 }
 
@@ -156,37 +135,19 @@ _install_nft() {
     # tool's traffic is affected. Priority -10 runs before Docker's
     # filter hooks (priority 0); a drop here is terminal for the packet.
     #
-    #   forward: VM egress is DNAT'd to the gateway (established via
+    #   forward: VM egress is DNAT'd to the sidecar (established via
     #     `ct status dnat`); return traffic via `ct state established`.
     #     Anything else from a VM is dropped -> no route to the internet
-    #     or the rest of the host except through the gateway proxy.
+    #     or the rest of the host except through the sidecar proxy.
-    #   input: a VM never needs host-local delivery (its gateway is
+    #   input: a VM never needs host-local delivery (its sidecar is
     #     reached via DNAT->forward), so drop all direct input from VMs
     #     -> host services bound on 0.0.0.0 are unreachable from the VM.
-    # Delete-first (create empty, delete, recreate) so a re-applied `up`
-    # lands identical state instead of appending rules / erroring on the
-    # existing base chains — the setup is idempotent regardless of history.
-
-    # Anti-spoof: bind each TAP to its assigned guest IP. The /31 alone
-    # does NOT make the source address unspoofable — root in an agent VM
-    # can source another bottle's guest IP on its own bbfc TAP, and the
-    # gateway attributes egress/policy/tokens by source IP. So drop any
-    # packet whose source isn't the guest address assigned to the exact
-    # TAP it arrived on, before it can be attributed. One rule per slot.
-    local antispoof="" i
-    for i in $(seq 0 $((POOL_SIZE-1))); do
-        antispoof="${antispoof}        iifname \"$(iface "$i")\" ip saddr != $(guest_ip "$i") drop
-"
-    done
-
     nft -f - <<EOF
-table inet $TABLE {}
-delete table inet $TABLE
 table inet $TABLE {
     chain forward {
         type filter hook forward priority -10; policy accept;
         iifname != "${PREFIX}*" return
-${antispoof}        ct state established,related accept
+        ct state established,related accept
         ct status dnat accept
         drop
     }
@@ -200,87 +161,8 @@ ${antispoof}        ct state established,related accept
 EOF
 }
 
-# Give the orchestrator/gateway VM real internet egress (agent VMs get
-# none — that's the isolation table above). Three parts, because the
-# path must work both during bootstrap (Docker still present) and after
-# Docker is removed:
-#   * masquerade   — SNAT the orch guest /31 out the host uplink so its
-#                    RFC-1918 address can reach the internet.
-#   * nft forward  — accept the orch link's forward path (load-bearing
-#                    on a pure-nft host whose FORWARD policy drops; a
-#                    harmless no-op where forwarding is already open).
-#                    It never drops, so it can't weaken the isolation
-#                    table's agent drops.
-#   * DOCKER-USER  — during bootstrap Docker's FORWARD chain policy is
-#                    DROP; its sanctioned DOCKER-USER hook is the only
-#                    place a user ACCEPT survives. Best-effort + guarded
-#                    (skipped once Docker is gone).
-_install_orch_egress() {
-    nft -f - <<EOF
-table inet ${TABLE}_nat {}
-delete table inet ${TABLE}_nat
-table inet ${TABLE}_nat {
-    chain forward {
-        type filter hook forward priority -10; policy accept;
-        iifname "$ORCH_IFACE" accept
-        oifname "$ORCH_IFACE" ct state established,related accept
-    }
-    chain postrouting {
-        type nat hook postrouting priority 100; policy accept;
-        ip saddr $(orch_guest) oifname != "$ORCH_IFACE" masquerade
-    }
-}
-EOF
-    _docker_user_orch add
-}
-
-# Insert (add) or delete (del) the DOCKER-USER ACCEPT rules for the
-# orchestrator link, idempotently, only when the chain exists.
-_docker_user_orch() {
-    local op="$1" flag
-    command -v iptables >/dev/null 2>&1 || return 0
-    iptables -t filter -L DOCKER-USER >/dev/null 2>&1 || return 0
-    for flag in "-i" "-o"; do
-        if [ "$op" = add ]; then
-            iptables -C DOCKER-USER "$flag" "$ORCH_IFACE" -j ACCEPT 2>/dev/null \
-                || iptables -I DOCKER-USER "$flag" "$ORCH_IFACE" -j ACCEPT
-        else
-            iptables -D DOCKER-USER "$flag" "$ORCH_IFACE" -j ACCEPT 2>/dev/null || true
-        fi
-    done
-}
-
-# Agent -> gateway VM routing. The shared gateway (egress / supervise /
-# git-http) runs in the orchestrator/infra VM at $(orch_guest). Agents keep
-# addressing their own host-side TAP IP on the gateway ports; a PREROUTING
-# DNAT redirects that to the infra VM, and the isolation table's
-# `ct status dnat accept` forward rule lets it through — every other agent
-# egress stays dropped. Source IP is deliberately NOT masqueraded: the
-# gateway attributes each request to the originating bottle by its (nft +
-# /31 unspoofable) guest IP.
-_install_gateway_route() {
-    nft -f - <<EOF
-table ip ${TABLE}_gw {}
-delete table ip ${TABLE}_gw
-table ip ${TABLE}_gw {
-    chain prerouting {
-        type nat hook prerouting priority -100; policy accept;
-        iifname "${PREFIX}*" tcp dport { $GATEWAY_PORTS } dnat to $(orch_guest)
-    }
-}
-EOF
-}
-
 cmd_down() {
     require_root down
-    _docker_user_orch del
-    nft delete table ip "${TABLE}_gw" 2>/dev/null || true
-    nft delete table inet "${TABLE}_nat" 2>/dev/null || true
-    if ip link show "$ORCH_IFACE" >/dev/null 2>&1; then
-        ip link set "$ORCH_IFACE" down 2>/dev/null || true
-        ip tuntap del dev "$ORCH_IFACE" mode tap 2>/dev/null || true
-        echo "  removed $ORCH_IFACE"
-    fi
     nft delete table inet "$TABLE" 2>/dev/null || true
     for i in $(seq 0 $((POOL_SIZE-1))); do
         local dev ; dev="$(iface "$i")"
@@ -296,10 +178,6 @@ cmd_down() {
 cmd_status() {
     echo "table inet $TABLE:"
     nft list table inet "$TABLE" 2>/dev/null || echo "  (absent)"
-    echo "table inet ${TABLE}_nat (orchestrator egress):"
-    nft list table inet "${TABLE}_nat" 2>/dev/null || echo "  (absent)"
-    echo "table ip ${TABLE}_gw (agent->gateway route):"
-    nft list table ip "${TABLE}_gw" 2>/dev/null || echo "  (absent)"
     echo "taps:"
     for i in $(seq 0 $((POOL_SIZE-1))); do
         local dev ; dev="$(iface "$i")"
@@ -307,9 +185,6 @@ cmd_status() {
             ip -brief addr show "$dev" | sed 's/^/  /'
         fi
     done
-    if ip -brief addr show "$ORCH_IFACE" >/dev/null 2>&1; then
-        ip -brief addr show "$ORCH_IFACE" | sed 's/^/  /'
-    fi
 }
 
 case "${1:-}" in

tests/README.md

@@ -18,7 +18,8 @@ tests/
     test_manifest_runtime.py
     ...                             # many others; see unit/ directory
   integration/
-    test_gateway_image.py
+    test_sidecar_bundle_image.py
+    test_sidecar_bundle_compose.py
     test_dry_run_plan.py
     test_orphan_cleanup.py
     ...
@@ -47,9 +48,12 @@ Discovery is invoked with `-t .` (top-level dir = repo root) so the
   the bottle's runtime, and creates zero Docker resources.
 - `test_orphan_cleanup.py` — `network_remove` is idempotent against
   missing resources, so the EXIT trap can call it unconditionally.
-- `test_gateway_image.py` — builds Dockerfile.gateway and
+- `test_sidecar_bundle_image.py` — builds Dockerfile.sidecars and
   probes that gitleaks / mitmdump / supervise are all reachable
-  inside the gateway image.
+  inside the bundle.
+- `test_sidecar_bundle_compose.py` — end-to-end compose-up of an
+  agent + bundle pair; verifies the agent reaches the bundle via
+  the legacy network aliases.
 
 ## Canaries
 

tests/integration/test_firecracker_launch.py

@@ -0,0 +1,142 @@
+"""Integration: Firecracker microVM launch.
+
+End-to-end against a real Firecracker microVM: prepare + launch a bottle
+on the firecracker backend and verify the agent execs after provisioning
+and that the egress proxy env is wired to the sidecar.
+
+Gated on the `backend status` result for firecracker (0 == the privileged
+TAP pool + nft isolation table are provisioned). Skips cleanly with setup
+instructions otherwise, so the suite runs on hosts without the pool.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import io
+import os
+import shutil
+import tempfile
+import unittest
+from pathlib import Path
+
+from bot_bottle.backend import BottleSpec, get_bottle_backend
+from bot_bottle.backend.firecracker import FirecrackerBottleBackend
+from bot_bottle.manifest import ManifestIndex
+
+
+def _firecracker_status_ok() -> bool:
+    """Gate on `./cli.py backend status --backend=firecracker`: a 0 exit
+    means the pool + nft table are ready. Output is captured so the
+    decorator stays quiet during collection; any error → not ready."""
+    buf = io.StringIO()
+    try:
+        with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf):
+            return FirecrackerBottleBackend.status() == 0
+    except Exception:
+        return False
+
+
+_SKIP_MSG = (
+    "firecracker backend not ready — provision the network pool with "
+    "`./cli.py backend setup --backend=firecracker`, then confirm with "
+    "`./cli.py backend status --backend=firecracker`"
+)
+
+
+def _minimal_agent_dockerfile(path: Path) -> None:
+    path.write_text(
+        "\n".join((
+            "FROM node:22-slim",
+            "RUN apt-get update \\",
+            "  && apt-get install -y --no-install-recommends \\",
+            "    ca-certificates curl git \\",
+            "  && rm -rf /var/lib/apt/lists/*",
+            "USER node",
+            "WORKDIR /home/node",
+            "CMD [\"sleep\", \"infinity\"]",
+            "",
+        )),
+        encoding="utf-8",
+    )
+
+
+def _minimal_manifest(dockerfile: Path) -> ManifestIndex:
+    return ManifestIndex.from_json_obj({
+        "bottles": {
+            "dev": {
+                "agent_provider": {
+                    "template": "pi",
+                    "dockerfile": str(dockerfile),
+                    "settings": {
+                        "provider": "example",
+                        "base_url": "https://example.com/v1",
+                        "models": ["smoke"],
+                    },
+                },
+                "egress": {"routes": [{"host": "example.com"}]},
+            },
+        },
+        "agents": {
+            "demo": {"skills": [], "prompt": "smoke", "bottle": "dev"},
+        },
+    })
+
+
+@unittest.skipIf(
+    os.environ.get("GITEA_ACTIONS") == "true",
+    "skipped under act_runner: cannot host Firecracker microVMs",
+)
+@unittest.skipUnless(_firecracker_status_ok(), _SKIP_MSG)
+class TestFirecrackerLaunch(unittest.TestCase):
+    """Launch once, reuse the bottle across probes."""
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.stage = Path(tempfile.mkdtemp(prefix="cb-firecracker-launch."))
+        cls._launch = None
+        cls.bottle = None
+        dockerfile = cls.stage / "Dockerfile.agent-smoke"
+        _minimal_agent_dockerfile(dockerfile)
+        os.environ["BOT_BOTTLE_BACKEND"] = "firecracker"
+        try:
+            backend = get_bottle_backend()
+            spec = BottleSpec(
+                manifest=_minimal_manifest(dockerfile),
+                agent_name="demo",
+                copy_cwd=False,
+                user_cwd=str(cls.stage),
+            )
+            cls.plan = backend.prepare(spec, stage_dir=cls.stage)
+            cls._launch = backend.launch(cls.plan)
+            cls.bottle = cls._launch.__enter__()
+        except BaseException:
+            if cls._launch is not None:
+                cls._launch.__exit__(None, None, None)
+            shutil.rmtree(cls.stage, ignore_errors=True)
+            os.environ.pop("BOT_BOTTLE_BACKEND", None)
+            raise
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        try:
+            if cls._launch is not None:
+                cls._launch.__exit__(None, None, None)
+        finally:
+            shutil.rmtree(cls.stage, ignore_errors=True)
+            os.environ.pop("BOT_BOTTLE_BACKEND", None)
+
+    def test_smoke_exec_echo(self) -> None:
+        r = self.bottle.exec("echo hello-from-firecracker")  # type: ignore[union-attr]
+        self.assertEqual(0, r.returncode, msg=r.stderr)
+        self.assertIn("hello-from-firecracker", r.stdout)
+
+    def test_proxy_env_points_at_sidecar(self) -> None:
+        r = self.bottle.exec(  # type: ignore[union-attr]
+            "printf '%s\\n' \"$HTTPS_PROXY\" \"$HTTP_PROXY\""
+        )
+        self.assertEqual(0, r.returncode, msg=r.stderr)
+        self.assertIn("http", r.stdout.lower())
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_macos_container_launch.py

@@ -0,0 +1,239 @@
+"""Integration: macOS Container launch topology.
+
+End-to-end against Apple's real `container` runtime. The smoke launches
+a bottle with the experimental macOS Container backend and verifies the
+properties that make the explicit-proxy launch acceptable:
+
+  - the agent can exec commands after provisioning;
+  - HTTP(S)_PROXY points at the sidecar's internal-network IP;
+  - allowlisted HTTPS reaches the egress sidecar;
+  - direct egress with proxy env removed fails from the internal-only
+    agent network;
+  - non-allowlisted proxy traffic is blocked.
+
+Skipped under Gitea Actions and on hosts without Apple's `container`.
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+
+from bot_bottle.backend import BottleSpec, get_bottle_backend
+from bot_bottle.backend.macos_container.util import (
+    dns_server as _container_dns_server,
+    is_available as _container_available,
+)
+from bot_bottle.manifest import ManifestIndex
+
+
+_AGENT_PROMPT = "You are a launch smoke-test agent. Be brief."
+
+
+def _minimal_agent_dockerfile(path: Path) -> None:
+    path.write_text(
+        "\n".join((
+            "FROM node:22-slim",
+            "RUN apt-get update \\",
+            "  && apt-get install -y --no-install-recommends \\",
+            "    ca-certificates curl git \\",
+            "  && rm -rf /var/lib/apt/lists/*",
+            "USER node",
+            "WORKDIR /home/node",
+            "CMD [\"sleep\", \"infinity\"]",
+            "",
+        )),
+        encoding="utf-8",
+    )
+
+
+def _minimal_manifest(dockerfile: Path) -> ManifestIndex:
+    return ManifestIndex.from_json_obj({
+        "bottles": {
+            "dev": {
+                "agent_provider": {
+                    "template": "pi",
+                    "dockerfile": str(dockerfile),
+                    "settings": {
+                        "provider": "example",
+                        "base_url": "https://example.com/v1",
+                        "models": ["smoke"],
+                    },
+                },
+                "egress": {
+                    "routes": [
+                        {"host": "example.com"},
+                    ],
+                },
+            },
+        },
+        "agents": {
+            "demo": {
+                "skills": [],
+                "prompt": _AGENT_PROMPT,
+                "bottle": "dev",
+            },
+        },
+    })
+
+
+def _buildkit_dns_available() -> bool:
+    if platform.system() != "Darwin" or not _container_available():
+        return False
+    stage = Path(tempfile.mkdtemp(prefix="cb-container-buildkit-dns."))
+    image = "bot-bottle-buildkit-dns-check:latest"
+    try:
+        dockerfile = stage / "Dockerfile"
+        dockerfile.write_text(
+            "FROM debian:bookworm-slim\n"
+            "RUN getent hosts deb.debian.org\n",
+            encoding="utf-8",
+        )
+        result = subprocess.run(
+            [
+                "container", "build",
+                "--dns", _container_dns_server(),
+                "-t", image,
+                "-f", str(dockerfile),
+                str(stage),
+            ],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+        return result.returncode == 0
+    finally:
+        subprocess.run(
+            ["container", "image", "delete", image],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+        shutil.rmtree(stage, ignore_errors=True)
+
+
+@unittest.skipIf(
+    os.environ.get("GITEA_ACTIONS") == "true",
+    "skipped under act_runner: cannot host Apple Container VMs",
+)
+@unittest.skipUnless(
+    platform.system() == "Darwin",
+    "Apple Container is macOS-only",
+)
+@unittest.skipUnless(
+    _container_available(),
+    "Apple Container not on PATH; install from "
+    "https://github.com/apple/container/releases",
+)
+@unittest.skipUnless(
+    _buildkit_dns_available(),
+    "Apple Container BuildKit cannot resolve deb.debian.org on this host",
+)
+class TestMacosContainerLaunch(unittest.TestCase):
+    """Launch once and reuse the bottle across probes."""
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.stage = Path(tempfile.mkdtemp(prefix="cb-macos-container-launch."))
+        cls._launch = None
+        cls.bottle = None
+        dockerfile = cls.stage / "Dockerfile.agent-smoke"
+        _minimal_agent_dockerfile(dockerfile)
+        os.environ["BOT_BOTTLE_BACKEND"] = "macos-container"
+        try:
+            backend = get_bottle_backend()
+            spec = BottleSpec(
+                manifest=_minimal_manifest(dockerfile),
+                agent_name="demo",
+                copy_cwd=False,
+                user_cwd=str(cls.stage),
+            )
+            cls.plan = backend.prepare(spec, stage_dir=cls.stage)
+            cls._launch = backend.launch(cls.plan)
+            cls.bottle = cls._launch.__enter__()
+        except BaseException:
+            if cls._launch is not None:
+                cls._launch.__exit__(None, None, None)
+            shutil.rmtree(cls.stage, ignore_errors=True)
+            os.environ.pop("BOT_BOTTLE_BACKEND", None)
+            raise
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        try:
+            if cls._launch is not None:
+                cls._launch.__exit__(None, None, None)
+        finally:
+            shutil.rmtree(cls.stage, ignore_errors=True)
+            os.environ.pop("BOT_BOTTLE_BACKEND", None)
+
+    def test_smoke_exec_echo(self):
+        r = self.bottle.exec(  # type: ignore[union-attr]
+            "echo hello-from-macos-container"
+        )
+        self.assertEqual(0, r.returncode, msg=r.stderr)
+        self.assertIn("hello-from-macos-container", r.stdout)
+
+    def test_proxy_env_points_at_sidecar_internal_ip(self):
+        r = self.bottle.exec(  # type: ignore[union-attr]
+            "printf '%s\n' \"$HTTPS_PROXY\" \"$HTTP_PROXY\" "
+            "\"$NO_PROXY\" \"$NODE_EXTRA_CA_CERTS\""
+        )
+        self.assertEqual(0, r.returncode, msg=r.stderr)
+        values = [line.strip() for line in r.stdout.splitlines()]
+        self.assertEqual(4, len(values), values)
+        self.assertEqual(values[0], values[1], values)
+        self.assertRegex(values[0], r"^http://[0-9.]+:9099$")
+        self.assertNotIn("127.0.0.1", values[0])
+        sidecar_host = values[0].removeprefix("http://").removesuffix(":9099")
+        self.assertIn(sidecar_host, values[2])
+        self.assertEqual(
+            "/usr/local/share/ca-certificates/bot-bottle-mitm-ca.crt",
+            values[3],
+        )
+
+    def test_allowlisted_https_reaches_egress_proxy(self):
+        r = self.bottle.exec(  # type: ignore[union-attr]
+            "curl -fsS --max-time 20 https://example.com >/dev/null && echo OK"
+        )
+        self.assertEqual(0, r.returncode, msg=r.stderr + r.stdout)
+        self.assertIn("OK", r.stdout)
+
+    def test_direct_egress_bypass_without_proxy_fails(self):
+        r = self.bottle.exec(  # type: ignore[union-attr]
+            "env -u HTTPS_PROXY -u HTTP_PROXY -u https_proxy -u http_proxy "
+            "curl -s --show-error --max-time 5 https://example.com 2>&1 || true"
+        )
+        self.assertTrue(
+            "refused" in r.stdout.lower()
+            or "timed out" in r.stdout.lower()
+            or "unreachable" in r.stdout.lower()
+            or "failed" in r.stdout.lower()
+            or "could not resolve" in r.stdout.lower()
+            or "connection reset" in r.stdout.lower(),
+            f"expected direct egress to fail; got: {r.stdout!r}",
+        )
+
+    def test_non_allowlisted_host_fails_through_proxy(self):
+        r = self.bottle.exec(  # type: ignore[union-attr]
+            "curl -s --show-error --max-time 10 https://iana.org 2>&1 || true"
+        )
+        self.assertTrue(
+            "403" in r.stdout
+            or "502" in r.stdout
+            or "blocked" in r.stdout.lower()
+            or "not allowed" in r.stdout.lower()
+            or "not in the bottle's egress.routes allowlist" in r.stdout.lower()
+            or "forbidden" in r.stdout.lower()
+            or "failed" in r.stdout.lower(),
+            f"expected non-allowlisted proxy request to fail; got: {r.stdout!r}",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

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.name = "bot-bottle-orch-sidecar-itest-" + secrets.token_hex(4)
-        self.sc = DockerGateway(IMAGE, name=self.name)
+        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,7 +1,7 @@
-"""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
-gateway (a heavy, slow image build) — it exercises the `image_exists`
+sidecar bundle (a heavy, slow image build) — it exercises the `image_exists`
 primitive that `ensure_built` gates on, against a tiny pulled image and a
 name that can't exist.
 """
@@ -11,24 +11,24 @@ 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.gateway build).
+        # so this never triggers a Dockerfile.sidecars build).
         subprocess.run(
             ["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/integration/test_orphan_cleanup.py

@@ -6,7 +6,7 @@ resources.
 
 The PipelockProxy.stop idempotency case that used to live here was
 removed in PRD 0024 chunk 3 when the per-container .stop method
-went away — gateway teardown is now compose's responsibility, and
+went away — sidecar teardown is now compose's responsibility, and
 `compose down` already no-ops on missing containers."""
 
 import os

tests/integration/test_sandbox_escape.py

@@ -72,7 +72,7 @@ _DUMMY_HOST_KEY = (
     os.environ.get("GITEA_ACTIONS") == "true",
     "skipped under act_runner: egress_tls_init uses a host bind mount "
     "the runner container can't see, and the network topology hides "
-    "sibling-gateway visibility — same constraint as the other "
+    "sibling-sidecar visibility — same constraint as the other "
     "bottle-bringup integration tests",
 )
 class TestSandboxEscape(unittest.TestCase):
@@ -90,8 +90,8 @@ class TestSandboxEscape(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls) -> None:
-        # Docker is always required (the agent + companion containers run under it,
+        # Docker is always required (the agent + sidecars run under it,
-        # and VM backends still use it for the gateway); the
+        # and VM backends still use it for the sidecar bundle); the
         # class-level @skip_unless_docker already covers that. Pin
         # Docker when BOT_BOTTLE_BACKEND is unset to preserve the
         # Docker-backed CI path.
@@ -121,7 +121,7 @@ class TestSandboxEscape(unittest.TestCase):
                     "egress": {
                         "routes": [{"host": "api.anthropic.com"}],
                     },
-                    # git-gate daemon so attack 5 can push. Upstream
+                    # git-gate sidecar so attack 5 can push. Upstream
                     # is intentionally unreachable — the pre-receive
                     # gitleaks hook must reject BEFORE git-gate
                     # attempts the upstream push. A preset `host_key`
@@ -275,7 +275,7 @@ class TestSandboxEscape(unittest.TestCase):
 
     def _assert_sandbox_block(self, label: str, r: object) -> None:  # type: ignore
         """A real sandbox block produces an HTTP 403 with a
-        recognizable sandbox gateway marker in the body. ANY
+        recognizable sandbox sidecar marker in the body. ANY
         other outcome (200 from upstream, 401/404 from upstream,
         non-marker 5xx) means the request escaped — the secret
         reached the network."""

tests/integration/test_sidecar_bundle_compose.py

@@ -0,0 +1,106 @@
+"""Integration: end-to-end smoke for the PRD 0024 bundle shape.
+
+Verifies that flipping `BOT_BOTTLE_SIDECAR_BUNDLE=1` produces a
+working bottle: `docker compose up` brings the agent + bundle pair
+online, the daemons inside the bundle bind their ports, and the
+agent can reach egress + supervise via the bundle's network
+aliases (no agent-side config changes between flag positions).
+
+Skipped under GITEA_ACTIONS — the bundle image is a multi-stage
+build pulling 200+MB of base layers, and the bind-mounts won't
+share filesystem with the runner container. Same constraint as
+the chunk-1 image-probe test.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from bot_bottle.backend import BottleSpec, get_bottle_backend
+from bot_bottle.manifest import ManifestIndex
+from tests._docker import skip_unless_docker
+
+
+def _manifest() -> ManifestIndex:
+    """Bottle with supervise on so the bundle exercises egress +
+    supervise. Git is off because a meaningful git-gate test needs
+    a real upstream and SSH keys — out of scope for a bundle smoke."""
+    return ManifestIndex.from_json_obj({
+        "bottles": {
+            "dev": {
+                "supervise": True,
+            },
+        },
+        "agents": {
+            "demo": {"skills": [], "prompt": "", "bottle": "dev"},
+        },
+    })
+
+
+@skip_unless_docker()
+@unittest.skipIf(
+    os.environ.get("GITEA_ACTIONS") == "true",
+    "skipped under act_runner: multi-stage bundle build pulls 200+MB "
+    "of base layers and bind-mounts don't share fs with the runner",
+)
+class TestSidecarBundleCompose(unittest.TestCase):
+    """One end-to-end pass with the bundle flag on. Skipping under
+    act_runner; the local docker daemon does the work."""
+
+    def test_bottle_up_with_bundle_flag_on(self):
+        stage_dir = Path(tempfile.mkdtemp(prefix="cb-bundle-smoke."))
+        try:
+            with patch.dict(os.environ, {"BOT_BOTTLE_SIDECAR_BUNDLE": "1"}):
+                backend = get_bottle_backend("docker")
+                spec = BottleSpec(
+                    manifest=_manifest(),
+                    agent_name="demo",
+                    copy_cwd=False,
+                    user_cwd=str(stage_dir),
+                )
+                plan = backend.prepare(spec, stage_dir=stage_dir)
+                with backend.launch(plan) as bottle:
+                    # The agent's HTTPS_PROXY URL (resolved at
+                    # renderer-time) should reach egress inside
+                    # the bundle. A bare CONNECT with no upstream
+                    # URL gets rejected with 400 or 405 but proves
+                    # the listener is alive at the alias.
+                    probe = bottle.exec(
+                        "set -eu\n"
+                        "echo HTTPS_PROXY=$HTTPS_PROXY\n"
+                        "PORT=$(echo \"$HTTPS_PROXY\" | sed -E 's|.*:([0-9]+).*|\\1|')\n"
+                        "HOST=$(echo \"$HTTPS_PROXY\" | sed -E 's|http://([^:]+):.*|\\1|')\n"
+                        "echo HOST=$HOST PORT=$PORT\n"
+                        "curl -sS --max-time 5 -o /dev/null -w 'http=%{http_code}\\n' "
+                        "  \"http://$HOST:$PORT/\" || true\n"
+                    )
+                    # The supervise URL resolves to the same bundle
+                    # via its supervise alias, on a different port.
+                    supervise_probe = bottle.exec(
+                        "set -eu\n"
+                        "curl -sS --max-time 5 -o /dev/null "
+                        "  -w 'http=%{http_code}\\n' "
+                        "  \"http://supervise:9100/health\" || true\n"
+                    )
+        finally:
+            shutil.rmtree(stage_dir, ignore_errors=True)
+
+        self.assertEqual(0, probe.returncode, msg=probe.stderr)
+        # egress answered SOMETHING — any 4xx is fine, just proves
+        # the egress daemon is listening at the proxy address.
+        self.assertIn("http=", probe.stdout,
+                      f"no HTTP response from egress: {probe.stdout!r}")
+        # supervise's /health endpoint exists (PRD 0013); it should
+        # answer 200 or similar — anything non-empty proves the
+        # third daemon's alias resolves to the same bundle.
+        self.assertEqual(0, supervise_probe.returncode, msg=supervise_probe.stderr)
+        self.assertIn("http=", supervise_probe.stdout)
+
+
+if __name__ == "__main__":
+    unittest.main()