From db9be8b9e260bb6302f55f6352b43ef20140be99 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20B=C3=BCrgi?=
 <6334612+rbuergi@users.noreply.github.com>
Date: Tue, 27 Oct 2026 10:21:25 +0100
Subject: [PATCH] move(core): the memex test container and the voice gateway
 leave core for MeshWeaver.Plugins (delete half)

src/MeshWeaver.Testcontainers and clients/voice-gateway move to MeshWeaver.Plugins (src/ and
clients/). Both were consumed only there: the test container's two consumers already lived in
Plugins, and nothing in core built or tested the voice gateway. Their Testcontainers and
Testcontainers.PostgreSql pins leave with them; no core project restores either.

MeshWeaver.Hosting.AspNetCore and MeshWeaver.Markdown.Export.Contract stay: a satellite's
compiled module derives from MeshEndpointProviderAttribute and compiles it from core source, and
the contract is pinned by Hosting.AspNetCore alone. clients/python stays: core's python-gate and
pandas-gate images COPY it. CarvingProjectsOutOfCore records all three verdicts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .claude/skills/i18n/SKILL.md                  |   2 +-
 .github/scripts/control-image-acceptance.sh   |   4 +-
 .github/workflows/clients.yml                 |  13 +-
 .github/workflows/dotnet-test.yml             |   2 +-
 Directory.Packages.props                      |   4 -
 MeshWeaver.slnx                               |   1 -
 clients/README.md                             |  38 +-
 clients/voice-gateway/.gitignore              |   5 -
 clients/voice-gateway/Dockerfile              |  19 -
 clients/voice-gateway/README.md               | 116 ----
 clients/voice-gateway/docker-compose.yml      |  20 -
 clients/voice-gateway/entrypoint.sh           |  16 -
 .../memex_voice_gateway/__init__.py           |   3 -
 .../memex_voice_gateway/__main__.py           | 235 -------
 .../memex_voice_gateway/config.py             | 227 -------
 .../memex_voice_gateway/homeassistant.py      |  81 ---
 .../memex_voice_gateway/musicassistant.py     |  77 ---
 .../memex_voice_gateway/ollama.py             | 369 -----------
 .../memex_voice_gateway/pipeline.py           | 194 ------
 .../memex_voice_gateway/router.py             | 574 ------------------
 .../memex_voice_gateway/satellite.py          | 292 ---------
 .../memex_voice_gateway/session.py            |  48 --
 .../voice-gateway/memex_voice_gateway/stt.py  |  64 --
 .../memex_voice_gateway/threads.py            | 203 -------
 .../voice-gateway/memex_voice_gateway/tts.py  | 236 -------
 .../voice-gateway/memex_voice_gateway/vad.py  |  94 ---
 clients/voice-gateway/pyproject.toml          |  25 -
 clients/voice-gateway/run-local.sh            |  23 -
 clients/voice-gateway/tests/test_context.py   | 202 ------
 clients/voice-gateway/tests/test_ollama.py    | 127 ----
 clients/voice-gateway/tests/test_pipeline.py  |  80 ---
 clients/voice-gateway/tests/test_router.py    | 243 --------
 clients/voice-gateway/tests/test_streaming.py |  73 ---
 clients/voice-gateway/tests/test_stt.py       |  15 -
 clients/voice-gateway/tests/test_threads.py   |  93 ---
 clients/voice-gateway/tests/test_vad.py       |  47 --
 clients/voice-gateway/wakeword/README.md      |  19 -
 clients/voice-gateway/wakeword/hey_memex.json |  18 -
 .../voice-gateway/wakeword/hey_memex.tflite   | Bin 62304 -> 0 bytes
 clients/voice-gateway/wakeword/phase2_data.py | 135 ----
 .../voice-gateway/wakeword/phase2_train.sh    |  62 --
 .../voice-gateway/wakeword/setup-hey-memex.sh |  33 -
 .../Architecture/CarvingProjectsOutOfCore.md  |  43 +-
 .../Data/Architecture/DockerHubInCi.md        |   2 +-
 .../DocsFollowTheFunctionality.md             |   5 +-
 .../Data/Architecture/FirstRunSetup.md        |   2 +-
 .../Architecture/InstanceIdentityAndSetup.md  |   2 +-
 .../Architecture/VoiceModelDistribution.md    |   4 +-
 .../MemexContainer.cs                         | 202 ------
 .../MemexReadiness.cs                         | 183 ------
 .../MeshWeaver.Testcontainers.csproj          |  21 -
 src/MeshWeaver.Testcontainers/README.md       |  50 --
 test/Directory.Packages.props                 |   1 -
 53 files changed, 74 insertions(+), 4573 deletions(-)
 delete mode 100644 clients/voice-gateway/.gitignore
 delete mode 100644 clients/voice-gateway/Dockerfile
 delete mode 100644 clients/voice-gateway/README.md
 delete mode 100644 clients/voice-gateway/docker-compose.yml
 delete mode 100644 clients/voice-gateway/entrypoint.sh
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/__init__.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/__main__.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/config.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/homeassistant.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/musicassistant.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/ollama.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/pipeline.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/router.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/satellite.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/session.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/stt.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/threads.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/tts.py
 delete mode 100644 clients/voice-gateway/memex_voice_gateway/vad.py
 delete mode 100644 clients/voice-gateway/pyproject.toml
 delete mode 100755 clients/voice-gateway/run-local.sh
 delete mode 100644 clients/voice-gateway/tests/test_context.py
 delete mode 100644 clients/voice-gateway/tests/test_ollama.py
 delete mode 100644 clients/voice-gateway/tests/test_pipeline.py
 delete mode 100644 clients/voice-gateway/tests/test_router.py
 delete mode 100644 clients/voice-gateway/tests/test_streaming.py
 delete mode 100644 clients/voice-gateway/tests/test_stt.py
 delete mode 100644 clients/voice-gateway/tests/test_threads.py
 delete mode 100644 clients/voice-gateway/tests/test_vad.py
 delete mode 100644 clients/voice-gateway/wakeword/README.md
 delete mode 100644 clients/voice-gateway/wakeword/hey_memex.json
 delete mode 100644 clients/voice-gateway/wakeword/hey_memex.tflite
 delete mode 100644 clients/voice-gateway/wakeword/phase2_data.py
 delete mode 100755 clients/voice-gateway/wakeword/phase2_train.sh
 delete mode 100755 clients/voice-gateway/wakeword/setup-hey-memex.sh
 delete mode 100644 src/MeshWeaver.Testcontainers/MemexContainer.cs
 delete mode 100644 src/MeshWeaver.Testcontainers/MemexReadiness.cs
 delete mode 100644 src/MeshWeaver.Testcontainers/MeshWeaver.Testcontainers.csproj
 delete mode 100644 src/MeshWeaver.Testcontainers/README.md

diff --git a/.claude/skills/i18n/SKILL.md b/.claude/skills/i18n/SKILL.md
index f93495b551..92136f8814 100644
--- a/.claude/skills/i18n/SKILL.md
+++ b/.claude/skills/i18n/SKILL.md
@@ -96,7 +96,7 @@ merge — and it is now the ONLY localization guard in this repo.
 
 The web clients' catalog lives at **`MeshWeaver.Plugins/clients/react/src/i18n/`**. `044a85618`
 ("The GUI leaves the platform", 2026-08-25) moved the web clients out; `clients/` in core now holds
-only `python/` and `voice-gateway/`, and the six guards the old text and the `Clients` workflow
+only `python/` (`voice-gateway/` followed to MeshWeaver.Plugins `clients/` in the core slimming), and the six guards the old text and the `Clients` workflow
 named — `i18n/localize.test.ts`, `render/parity.test.ts`, `ciTrigger.test.ts`,
 `grpc-web/src/{wire,rest}Contract.test.ts`, `portal-next/e2e` — no longer exist **in this repo**. Do
 not recreate them here; the mirror belongs where the client lives.
diff --git a/.github/scripts/control-image-acceptance.sh b/.github/scripts/control-image-acceptance.sh
index 38afd00295..bedd55289b 100755
--- a/.github/scripts/control-image-acceptance.sh
+++ b/.github/scripts/control-image-acceptance.sh
@@ -107,8 +107,8 @@ fi
 grep 'Database migration completed' "$MIGLOG" | tail -n 1
 
 # boot_and_wait <leg> <image>: start the image, wait for /health then /ready inside the budget,
-# then stop it. The environment is the chart's self-host minimum (MeshWeaver.Testcontainers'
-# MemexBuilder): Postgres for nodes, the filesystem backend, single-node Localhost clustering, no
+# then stop it. The environment is the chart's self-host minimum (MeshWeaver.Plugins'
+# src/MeshWeaver.Testcontainers MemexBuilder): Postgres for nodes, the filesystem backend, single-node Localhost clustering, no
 # dev login. Nothing control-specific is passed: the closed type set, the seeded module and the
 # disabled sweep are properties of the IMAGE, which is exactly what is under test.
 boot_and_wait() {
diff --git a/.github/workflows/clients.yml b/.github/workflows/clients.yml
index 14e95dfd82..db170bd51e 100644
--- a/.github/workflows/clients.yml
+++ b/.github/workflows/clients.yml
@@ -24,8 +24,8 @@ name: Clients
 #
 # THIS LIST WAS MUCH LONGER, and most of it is now WRONG rather than merely unused. `044a85618`
 # ("The GUI leaves the platform: the view packs and the web clients", 2026-08-25) moved the web
-# clients to MeshWeaver.Plugins. `clients/` holds only `python/` and `voice-gateway/`, one job
-# survives (`python-sdk`), and EVERY test the old inventory named is gone from this repo:
+# clients to MeshWeaver.Plugins. `clients/` holds only `python/` (`voice-gateway/` followed in the
+# core slimming), one job survives (`python-sdk`), and EVERY test the old inventory named is gone from this repo:
 #
 #     clients/react/src/i18n/localize.test.ts        clients/grpc-web/src/wireContract.test.ts
 #     clients/react/src/render/parity.test.ts        clients/grpc-web/src/restContract.test.ts
@@ -44,11 +44,10 @@ name: Clients
 # for the surviving clients, this list is maintained BY HAND and will rot again. If you add a
 # cross-tree read to `clients/python`, add its path here yourself.
 #
-# 🚨 `clients/voice-gateway` HAS NO JOB HERE — this workflow runs `python-sdk` and nothing
-# else, so a voice-gateway change triggers a run that does not test it. Adding a path for it would
-# make that worse, not better: the run would go green having verified nothing about the thing that
-# changed, which is precisely the "fires reliably, checks nothing" state this comment block exists
-# to record. If voice-gateway needs CI, it needs a JOB first, and its inputs listed second.
+# `clients/voice-gateway` used to sit here with NO job: a change to it triggered a run that tested
+# nothing about it. It moved to MeshWeaver.Plugins `clients/voice-gateway` (core slimming), where
+# its own `Voice gateway` workflow runs its suite. `clients/python` stays: core's own python-gate and
+# pandas-gate images COPY it, and it generates from core's canonical proto.
 #
 # The original rationale, still correct and still the reason the protos path is listed:
 # filtering on "clients/**" alone made every cross-tree guard blind to the side that actually
diff --git a/.github/workflows/dotnet-test.yml b/.github/workflows/dotnet-test.yml
index 6aa66e796c..d5e0cf7942 100644
--- a/.github/workflows/dotnet-test.yml
+++ b/.github/workflows/dotnet-test.yml
@@ -994,7 +994,7 @@ jobs:
     # 🚨 This job used to pre-pull `pgvector/pgvector:pg17` from Docker Hub, anonymously, on every
     # shard. Since the Postgres suites left core (the test-move tranches, #2847 and its successors)
     # NO core suite starts a container: nothing references Testcontainers.PostgreSql, and the one
-    # project that named MeshWeaver.Testcontainers (Memex.Portal.Shared.Test, now in
+    # project that named MeshWeaver.Testcontainers (Memex.Portal.Shared.Test; both now live in
     # MeshWeaver.Plugins) exercises readiness logic against an in-process host. So the pull fetched an image nothing used — and on 2026-10-09 it
     # was the ONLY red of six shards × several PRs (#6381 among them), Docker Hub answering
     # `toomanyrequests` to the runner pool's shared egress IP. Retrying a per-IP window is not a
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 4635600aea..ee78690a83 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -78,10 +78,6 @@
     <PackageVersion Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.20.1" />
     <PackageVersion Include="OpenTelemetry.Instrumentation.Http" Version="1.20.1" />
     <PackageVersion Include="OpenTelemetry.Instrumentation.Runtime" Version="1.20.1" />
-    <!-- The memex test container package (src/MeshWeaver.Testcontainers): a real memex from the
-         platform build as a test substrate, the way Testcontainers.PostgreSql gives a test a real
-         Postgres. Same version as the test tree pins. -->
-    <PackageVersion Include="Testcontainers" Version="4.16.0" />
     <PackageVersion Include="SSH.NET" Version="2026.0.0" /> <!-- High GHSA-q939-rpr3-3284; transitive via Testcontainers, direct-ref override in test/Directory.Build.props -->
     <!-- 🚨 THESE TWO ARE ONE FAMILY AND MUST MOVE TOGETHER — they were SPLIT, and the split was
          invisible because both halves were green.
diff --git a/MeshWeaver.slnx b/MeshWeaver.slnx
index 6b6a08386a..b355e35206 100644
--- a/MeshWeaver.slnx
+++ b/MeshWeaver.slnx
@@ -40,7 +40,6 @@
     <Project Path="test/MeshWeaver.Fixture/MeshWeaver.Fixture.csproj" />
     <Project Path="src/MeshWeaver.Reactive.Assertions/MeshWeaver.Reactive.Assertions.csproj" />
     <Project Path="src/MeshWeaver.Testing.InMesh/MeshWeaver.Testing.InMesh.csproj" />
-    <Project Path="src/MeshWeaver.Testcontainers/MeshWeaver.Testcontainers.csproj" />
     <Project Path="src/MeshWeaver.Hosting.AspNetCore/MeshWeaver.Hosting.AspNetCore.csproj" />
     <Project Path="src/MeshWeaver.Graph/MeshWeaver.Graph.csproj" />
     <Project Path="src/MeshWeaver.Graph.Contract/MeshWeaver.Graph.Contract.csproj" />
diff --git a/clients/README.md b/clients/README.md
index 461aa9c35d..808cc3c82b 100644
--- a/clients/README.md
+++ b/clients/README.md
@@ -1,8 +1,7 @@
 # MeshWeaver clients
 
-Foreign-language and cross-platform clients that **join the mesh** (transport) and **render mesh layout
-areas** (UI) — the same `UiControl` tree the Blazor portal and MAUI app render, reached over gRPC instead
-of SignalR.
+Foreign-language clients that **join the mesh** over gRPC — the same participant role the portal plays
+over SignalR.
 
 Full architecture: `src/MeshWeaver.Documentation/Data/Architecture/ForeignLanguageIntegration.md`
 (transport deep-dive: `ForeignLanguageBridge.md`).
@@ -11,26 +10,19 @@ Full architecture: `src/MeshWeaver.Documentation/Data/Architecture/ForeignLangua
 
 | Path | Package | What it is |
 |---|---|---|
-| [`python/`](python/) | `meshweaver` | Python SDK — `grpc.aio` transport + mesh operations |
-| [`typescript/`](typescript/) | `@meshweaver/client` | Node/Bun SDK — `@grpc/grpc-js`, bidi `Open`, `AsyncIterable` streams |
-| [`grpc-web/`](grpc-web/) | `@meshweaver/client-web` | Browser + React Native client — gRPC-web `Connect`+`Deliver` split (Connect-ES) + `Mesh` ops |
-| [`react/`](react/) | `@meshweaver/react` | Fluent UI renderer — swappable core + web pack + `GrpcAreaSource` |
-| [`react-native/`](react-native/) | `meshweaver-mobile` | Expo app + native leaf pack — the MAUI peer (live via `client-web`) |
-| [`portal/`](portal/) | `@meshweaver/portal-example` | a web portal built from the renderer |
-
-## The two ideas
-
-- **Transport-agnostic mesh.** A foreign process is a first-class participant over a gRPC bidi stream — the
-  same role MAUI/SignalR play. Protobuf frames the connection; the existing `IMessageDelivery` JSON carries
-  the message, so the whole serialization/identity stack is reused.
-- **Platform-agnostic UI.** A layout area is a JSON `UiControl` tree. The React renderer's core
-  (`@meshweaver/react/core`) dispatches/binds/lays-out with **no concrete component**, pulling a "leaf pack"
-  from context. Web/Electron/Next.js use the Fluent DOM pack; React Native uses a `<View>` pack — the direct
-  analog of MAUI's `MauiViewPack` vs Blazor's web renderers.
+| [`python/`](python/) | `meshweaver` | Python SDK — `grpc.aio` transport + mesh operations, and the Python worker |
+
+**Why the Python SDK stays in the platform repository.** Two images this repository builds COPY it —
+`deploy/python-gate` and `deploy/pandas-gate` — and it generates its stubs from the platform's one
+canonical proto (`src/MeshWeaver.Mesh.Contract/Protos/mesh.proto`). Moving it would make a core image
+depend on another repository.
+
+**Everything else left.** The web, desktop and mobile clients (`typescript/`, `grpc-web/`, `react/`,
+`react-native/`, `portal/`, `portal-next/`) and the voice gateway (`voice-gateway/`, an ESPHome voice
+satellite wired to agent threads) live in MeshWeaver.Plugins `clients/`, beside the hosts and the Speech
+module they talk to.
 
 ## CI
 
-`.github/workflows/clients.yml` runs on any PR touching `clients/`: `meshweaver` (Python) pytest,
-`@meshweaver/react` typecheck + vitest, `@meshweaver/client` (Node) typecheck, `@meshweaver/client-web`
-typecheck + vitest (buf-generates from the canonical `mesh.proto`), the RN connector typecheck + headless
-render tests, and the portal build. Both gRPC-codegen jobs generate from the one canonical `mesh.proto`.
+`.github/workflows/clients.yml` runs the `meshweaver` (Python) pytest on any change under `clients/` or to
+the canonical proto.
diff --git a/clients/voice-gateway/.gitignore b/clients/voice-gateway/.gitignore
deleted file mode 100644
index 59fb8f0f87..0000000000
--- a/clients/voice-gateway/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-.venv/
-__pycache__/
-*.egg-info/
-.pytest_cache/
-.env
diff --git a/clients/voice-gateway/Dockerfile b/clients/voice-gateway/Dockerfile
deleted file mode 100644
index 5603f8787d..0000000000
--- a/clients/voice-gateway/Dockerfile
+++ /dev/null
@@ -1,19 +0,0 @@
-# memex-voice-gateway — ESPHome voice satellite ↔ MeshWeaver threads, no Home Assistant.
-FROM python:3.12-slim
-
-# piper-tts brings the `piper` CLI + onnxruntime; the voice model is fetched at runtime
-# by the entrypoint (kept out of the image, same policy as deploy/whisper).
-RUN pip install --no-cache-dir piper-tts
-
-WORKDIR /app
-COPY pyproject.toml ./
-COPY memex_voice_gateway ./memex_voice_gateway
-RUN pip install --no-cache-dir .
-
-COPY entrypoint.sh /entrypoint.sh
-RUN chmod +x /entrypoint.sh
-
-# TTS file server the satellite fetches audio from — must be reachable on the LAN.
-EXPOSE 8200
-
-ENTRYPOINT ["/entrypoint.sh"]
diff --git a/clients/voice-gateway/README.md b/clients/voice-gateway/README.md
deleted file mode 100644
index 3bef08b7b5..0000000000
--- a/clients/voice-gateway/README.md
+++ /dev/null
@@ -1,116 +0,0 @@
-# memex-voice-gateway
-
-Wires an **ESPHome voice satellite** (built for the
-[FutureProofHomes Satellite1](https://github.com/FutureProofHomes/Satellite1-ESPHome)) directly to
-**MeshWeaver agent threads** — no Home Assistant required. One container on any always-on LAN box.
-
-```
-Satellite1 (wake word on-device, XMOS AEC)
-   │ mic audio (ESPHome native API, this gateway dials the device)
-   ▼
-memex-voice-gateway
-   ├─ endpointing (energy VAD)                          [vad.py]
-   ├─ STT  → POST {MEMEX_URL}/api/speech/transcribe     [stt.py]   Swiss German Whisper container
-   ├─ chat → /mcp start_thread / submit_message          [threads.py]  one conversation ≈ one thread
-   └─ TTS  → Piper (de_DE) served over HTTP              [tts.py]   device plays the URL
-```
-
-**Latency reality (measured 2026-08-18):** a memex thread round takes ~60–70 s wall clock —
-dispatch/startup, not generation. The gateway therefore answers inline only when the reply lands
-within `REPLY_BUDGET_S`; otherwise it speaks a short holding phrase, ends the voice run, and
-delivers the real answer as an **announcement** when it arrives. If platform dispatch gets faster,
-the same code starts answering inline — nothing to change.
-
-## Quick start
-
-1. **Mint a token**: memex portal → Settings ▸ Security ▸ API Tokens → label `voice-gateway`.
-   The gateway acts as *you* on the mesh — anyone who talks to the speaker does too.
-2. **Get the device's API encryption key** from your Satellite1's ESPHome config (`api: encryption:`).
-3. Create `.env` next to `docker-compose.yml`:
-
-   ```env
-   SATELLITE_HOST=192.168.1.42
-   SATELLITE_PSK=<the device's api encryption key>
-   MEMEX_TOKEN=mw_…
-   MEMEX_NAMESPACE=<your user id>
-   GATEWAY_HOST=192.168.1.10        # THIS machine's LAN IP — the satellite fetches TTS audio here
-   ```
-
-4. `docker compose up --build -d`, say the wake word, ask something.
-
-## All-local mode (Mac)
-
-Every leg is pluggable, so the gateway also runs **fully local** — no cloud in the loop, and
-(since the Swiss German Whisper model is CC BY-NC) the unambiguously non-commercial setup:
-
-| Leg | Mesh-hosted (default) | Local |
-|---|---|---|
-| STT | `{MEMEX_URL}/api/speech/transcribe` | `STT_URL=http://127.0.0.1:8090/inference` — whisper.cpp with the same Swiss German GGML |
-| Brain | `BRAIN=memex` (agent threads) | `BRAIN=ollama` + `OLLAMA_MODEL=qwen3.6` (or any pulled model) |
-| TTS | Piper (container) | `TTS_ENGINE=say` — macOS built-in voices (`SAY_VOICE=Anna`) |
-
-```bash
-brew install whisper-cpp ollama
-# The model lives on the PRIVATE MeshWeaver.Plugins repo (moved 2026-08-28; it is a
-# Systemorph-tuned model, deliberately not world-downloadable). Requires `gh auth login`.
-mkdir -p ~/models/whisper && gh release download voice-model-swiss-german --repo Systemorph/MeshWeaver.Plugins --pattern 'ggml-swiss-german-turbo-q5_0.bin' --dir ~/models/whisper
-pip install -e .
-SATELLITE_HOST=… SATELLITE_PSK=… GATEWAY_HOST=<this Mac's LAN IP> ./run-local.sh
-```
-
-Mix and match freely — e.g. local STT with the memex-thread brain is the best of both while
-the mesh's whisper container isn't deployed. (Apple Intelligence as a brain would need a small
-Swift helper around the Foundation Models framework — it has no HTTP API; Ollama is the
-practical local brain today.)
-
-## The Voice agent
-
-Point `MEMEX_AGENT` at a **lean** agent (short instructions, `chat` model tier, at most the Mesh
-Get/Search plugin). The platform's default assistant carries ~12k tokens of context into every
-round — fine in the portal, wasteful when the reply is one spoken sentence.
-
-## Coexisting with Home Assistant
-
-The device accepts multiple ESPHome API clients, so HA can own the satellite's **sensors, music
-and multi-room audio** while this gateway owns **voice** — but only ONE client may subscribe as
-the voice assistant. If you run HA alongside: do **not** assign the satellite to an Assist
-pipeline there. (Apple Music on the satellite = HA + Music Assistant; Siri cannot run on the
-device — but an Apple Shortcut on your phone can call the same thread API.)
-
-## Configuration reference
-
-| Variable | Default | Meaning |
-|---|---|---|
-| `SATELLITE_HOST` / `SATELLITE_PORT` | — / `6053` | the device's LAN address |
-| `SATELLITE_PSK` | — | ESPHome API encryption key (`SATELLITE_PASSWORD` for legacy auth) |
-| `MEMEX_URL` | `https://memex.meshweaver.cloud` | the mesh |
-| `MEMEX_TOKEN` | — | `mw_…` bearer token |
-| `MEMEX_NAMESPACE` | — | where threads are created (`{ns}/_Thread/…`) |
-| `MEMEX_AGENT` | `Voice` | agent name; empty = platform default |
-| `GATEWAY_HOST` / `GATEWAY_PORT` | — / `8200` | LAN address the satellite fetches TTS from |
-| `STT_LANGUAGE` | `de` | `de` transcribes Swiss German OUT as Standard German |
-| `REPLY_BUDGET_S` | `10` | wait this long before acking with the holding phrase |
-| `ANNOUNCE_BUDGET_S` | `240` | keep polling this long, then announce the answer |
-| `THREAD_IDLE_MINUTES` | `5` | follow-up questions reuse the same thread within this window |
-| `HOLD_PHRASE` / `ERROR_PHRASE` | German defaults | what the speaker says meanwhile / on failure |
-| `PIPER_VOICE` / `PIPER_VOICE_URL` | thorsten-medium | High German TTS voice |
-
-## Development
-
-```bash
-pip install -e .[dev]
-pytest
-```
-
-The device protocol follows the same `aioesphomeapi` surface Home Assistant's ESPHome
-integration uses (`subscribe_voice_assistant` in API-audio mode, `send_voice_assistant_event`,
-announcements with a media-player fallback). The thread and STT clients are unit-tested against
-the live-verified wire shapes; the device leg needs a real satellite to verify end-to-end.
-
-## Speech model license
-
-The default STT model behind `/api/speech/transcribe` is a derivative of
-[Flurin17/whisper-large-v3-turbo-swiss-german](https://huggingface.co/Flurin17/whisper-large-v3-turbo-swiss-german)
-(**CC BY-NC 4.0 — non-commercial use only**). A personal home assistant is non-commercial use;
-for anything commercial, point the whisper container at a permissively licensed model
-(see `deploy/whisper/README.md`).
diff --git a/clients/voice-gateway/docker-compose.yml b/clients/voice-gateway/docker-compose.yml
deleted file mode 100644
index 91bd0ec31a..0000000000
--- a/clients/voice-gateway/docker-compose.yml
+++ /dev/null
@@ -1,20 +0,0 @@
-# memex-voice-gateway — fill in the four secrets/addresses in .env (see README).
-services:
-  voice-gateway:
-    build: .
-    restart: unless-stopped
-    network_mode: host   # the satellite must reach the TTS server; host networking keeps URLs simple
-    environment:
-      SATELLITE_HOST: "${SATELLITE_HOST}"          # the Satellite1's LAN IP or mDNS name
-      SATELLITE_PSK: "${SATELLITE_PSK:-}"          # the device's ESPHome API encryption key
-      MEMEX_URL: "${MEMEX_URL:-https://memex.meshweaver.cloud}"
-      MEMEX_TOKEN: "${MEMEX_TOKEN}"                # mw_… token (Settings ▸ Security ▸ API Tokens)
-      MEMEX_NAMESPACE: "${MEMEX_NAMESPACE}"        # thread namespace, e.g. your user id
-      MEMEX_AGENT: "${MEMEX_AGENT:-Voice}"
-      GATEWAY_HOST: "${GATEWAY_HOST}"              # THIS machine's LAN IP (satellite fetches TTS here)
-      STT_LANGUAGE: "de"
-    volumes:
-      - piper-voices:/voices
-
-volumes:
-  piper-voices:
diff --git a/clients/voice-gateway/entrypoint.sh b/clients/voice-gateway/entrypoint.sh
deleted file mode 100644
index 2ecf760412..0000000000
--- a/clients/voice-gateway/entrypoint.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/sh
-set -e
-
-# Fetch the Piper voice on first start (≈60 MB, kept in the /voices volume).
-# High German out: the Swiss German Whisper fine-tune transcribes dialect INTO Standard
-# German, and the assistant answers in Standard German.
-VOICE="${PIPER_VOICE:-/voices/de_DE-thorsten-medium.onnx}"
-VOICE_URL="${PIPER_VOICE_URL:-https://huggingface.co/rhasspy/piper-voices/resolve/main/de/de_DE/thorsten/medium/de_DE-thorsten-medium.onnx}"
-if [ ! -f "$VOICE" ]; then
-    mkdir -p "$(dirname "$VOICE")"
-    echo "Fetching Piper voice → $VOICE"
-    python -c "import urllib.request,sys; urllib.request.urlretrieve('$VOICE_URL', '$VOICE')"
-    python -c "import urllib.request; urllib.request.urlretrieve('$VOICE_URL.json', '$VOICE.json')"
-fi
-
-exec memex-voice-gateway
diff --git a/clients/voice-gateway/memex_voice_gateway/__init__.py b/clients/voice-gateway/memex_voice_gateway/__init__.py
deleted file mode 100644
index cd9f93461e..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-"""memex-voice-gateway: an ESPHome voice satellite wired directly to MeshWeaver threads."""
-
-__version__ = "0.1.0"
diff --git a/clients/voice-gateway/memex_voice_gateway/__main__.py b/clients/voice-gateway/memex_voice_gateway/__main__.py
deleted file mode 100644
index c13ad0c102..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/__main__.py
+++ /dev/null
@@ -1,235 +0,0 @@
-"""Entry point: wire config → STT → brain → TTS → satellite, then run forever."""
-
-from __future__ import annotations
-
-import asyncio
-import functools
-import logging
-import re
-
-import aiohttp
-
-from . import stt
-from .config import Config, phrases_for
-from .ollama import OllamaBrain
-from .pipeline import VoicePipeline
-from .router import BrainRouter
-from .satellite import SatelliteLink
-from .threads import MemexThreads
-from .tts import PiperTts, SayTts, TtsFileServer, split_wav
-
-SENTENCE_END = re.compile(r"[.!?…][\"')\]]*\s")
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
-
-
-DIALECT_SUFFIX = (
-    " Antworte auf Schweizerdeutsch (Züritüütsch), schreibe den Dialekt phonetisch aus."
-)
-
-
-def make_router(cfg: Config) -> BrainRouter:
-    """One router over all configured brains — PORTALS entries, else the legacy single brain."""
-    from .config import phrases_for
-    from .ollama import SYSTEM_PROMPT
-    phrases = phrases_for(cfg.stt_language)
-    base_prompt = SYSTEM_PROMPT
-    if cfg.system_prompt_file:
-        try:
-            with open(cfg.system_prompt_file) as f:
-                base_prompt = f.read().strip() or SYSTEM_PROMPT
-        except OSError:
-            logging.getLogger(__name__).warning(
-                "SYSTEM_PROMPT_FILE %s not readable — using the built-in prompt",
-                cfg.system_prompt_file)
-    system_prompt = base_prompt + (DIALECT_SUFFIX if cfg.speak_dialect else "")
-
-    def ollama(entry: dict) -> OllamaBrain:
-        return OllamaBrain(entry.get("url", cfg.ollama_url), entry.get("model", cfg.ollama_model),
-                           idle_minutes=cfg.thread_idle_minutes, system_prompt=system_prompt,
-                           location=cfg.location)
-
-    def memex(entry: dict) -> MemexThreads:
-        return MemexThreads(entry["url"].rstrip("/"), entry["token"], entry["namespace"],
-                            agent=entry.get("agent", cfg.agent),
-                            thread_idle_minutes=cfg.thread_idle_minutes,
-                            verify_tls=not entry.get("insecure", False))
-
-    home = None
-    if cfg.ha_url and cfg.ha_token:
-        from .homeassistant import HomeAssistant
-        home = HomeAssistant(cfg.ha_url, cfg.ha_token)
-
-    if cfg.portals:
-        brains = {e["name"]: (ollama(e) if e.get("kind") == "ollama" else memex(e))
-                  for e in cfg.portals}
-        active = next((e["name"] for e in cfg.portals if e.get("default")), cfg.portals[0]["name"])
-        # A portal entry's "agents" pins agents to the portal that HOSTS them (list of
-        # names, or name → spoken-roster description) — e.g. the ExecutiveAssistant on the
-        # local mesh: {"name":"mac", …, "agents": {"ExecutiveAssistant": "email"}}.
-        from .ollama import DEFAULT_AGENTS, HOME_TOOL, MESH_TOOL, MESH_TOOLS
-        roster = dict(DEFAULT_AGENTS)
-        agent_homes: dict[str, str] = {}
-        for entry in cfg.portals:
-            declared = entry.get("agents") or {}
-            if isinstance(declared, list):
-                declared = {name: roster.get(name, "specialist work") for name in declared}
-            for name, description in declared.items():
-                roster[name] = description
-                agent_homes[name] = entry["name"]
-        router = BrainRouter(brains, active, phrases=phrases, home=home,
-                             agent_homes=agent_homes)
-        router.allow_destructive = cfg.allow_destructive
-        # The local brain TRIAGES: quick lookups through the normal tools (search_mesh,
-        # get_node, mesh_tool = full MCP, home_assistant), real work through
-        # delegate_to_memex — a mesh thread the context sticks to.
-        for brain in brains.values():
-            if isinstance(brain, OllamaBrain):
-                brain.delegator = router.delegate_task
-                brain.tool_runner = router.run_tool
-                brain.tools = (list(MESH_TOOLS) + [MESH_TOOL]
-                               + ([HOME_TOOL] if home is not None else []))
-                brain.agents = roster
-        # The SESSION COOKIE: resume the speaker's context within the TTL, persist on
-        # every context mutation — an MCP-session-style continuity for the voice.
-        from .session import SpokenSession
-        session = SpokenSession(cfg.session_file, cfg.session_ttl_h)
-        router.restore(session.load())
-        router.on_change = lambda: session.save(**router.session_state())
-        return router
-    if cfg.brain == "ollama":
-        return BrainRouter({"lokal": ollama({})}, "lokal", phrases=phrases, home=home)
-    return BrainRouter({"memex": memex({"url": cfg.memex_url, "token": cfg.memex_token,
-                                        "namespace": cfg.namespace})}, "memex",
-                       phrases=phrases, home=home)
-
-
-def make_tts(cfg: Config):
-    if cfg.tts_engine == "say":
-        return SayTts(cfg.say_voice)
-    return PiperTts(cfg.piper_bin, cfg.piper_voice)
-
-
-async def run() -> None:
-    cfg = Config.from_env()
-    http = aiohttp.ClientSession()
-    router = make_router(cfg)
-    # The prompt comes FROM THE PLATFORM: @Voice/Prompt (the package's standard) seeds
-    # @{user}/Voice/Prompt (the user's editable copy), which wins; SYSTEM_PROMPT_FILE
-    # stays the strongest override for local experiments. CAPABILITIES are then injected
-    # by what is actually installed — radio stations, smart home — never hard-coded.
-    from .ollama import SYSTEM_PROMPT
-    prompt_text = SYSTEM_PROMPT
-    if not cfg.system_prompt_file:
-        try:
-            prompt_text = (await router.sync_system_prompt(SYSTEM_PROMPT)).strip() or SYSTEM_PROMPT
-        except Exception:
-            pass
-    try:
-        await router.refresh_stations()
-    except Exception:
-        logging.getLogger(__name__).warning("station refresh failed", exc_info=True)
-    if cfg.ma_token:
-        from .musicassistant import MusicAssistant
-        router.music = MusicAssistant(cfg.ma_url, cfg.ma_token)
-    capabilities = []
-    if router.stations:
-        names = ", ".join(name for name, _ in router.stations.values())
-        capabilities.append(f"Radio is available ({names}) and handled for you "
-                            "automatically — never claim you cannot play radio.")
-    if router.music is not None:
-        capabilities.append("Specific songs and playlists play through the connected "
-                            "music services — also handled for you automatically.")
-    if cfg.ha_url and cfg.ha_token:
-        capabilities.append("The smart home is reachable through the home_assistant tool.")
-    router.apply_system_prompt(prompt_text
-                               + (DIALECT_SUFFIX if cfg.speak_dialect else "")
-                               + ("\n\n" + " ".join(capabilities) if capabilities else ""))
-    tts = make_tts(cfg)
-    server = TtsFileServer(cfg.gateway_host, cfg.gateway_port)
-    await server.start()
-
-    async def speak(text: str) -> str:
-        return server.add(await tts.synthesize(text))
-
-    async def stream_speak(chunks) -> str:
-        """Speak a live text stream: open a chunked-WAV session (the device starts playing
-        the URL immediately), synthesize sentence-by-sentence as pieces arrive, close on end.
-        Both `say` (forced LEI16@22050) and the piper medium voices emit 22.05 kHz."""
-        stream, url = server.open_stream(sample_rate=16000)
-
-        async def feed() -> None:
-            buffer = ""
-
-            async def speak_piece(text: str) -> None:
-                pcm, _ = split_wav(await tts.synthesize(text))
-                await stream.push(pcm)
-
-            try:
-                async for piece in chunks:
-                    buffer += piece
-                    while (match := SENTENCE_END.search(buffer)) is not None:
-                        sentence, buffer = buffer[:match.end()].strip(), buffer[match.end():]
-                        if sentence:
-                            await speak_piece(sentence)
-                if buffer.strip():
-                    await speak_piece(buffer.strip())
-            except Exception:
-                logging.getLogger(__name__).exception("streaming synthesis failed")
-            finally:
-                await stream.close()
-
-        asyncio.create_task(feed())
-        return url
-
-    link: SatelliteLink | None = None
-
-    async def announce(url: str, text: str) -> None:
-        if link is not None:
-            await link.announce(url, text)
-
-    pipeline = VoicePipeline(
-        transcribe=functools.partial(stt.transcribe, http, cfg.stt_url, cfg.stt_token,
-                                     language=cfg.stt_language, sample_rate=cfg.sample_rate),
-        ask=router.ask,
-        await_reply=router.await_reply,
-        speak=speak,
-        announce=announce,
-        reply_budget_s=cfg.reply_budget_s,
-        announce_budget_s=cfg.announce_budget_s,
-        hold_phrase=cfg.hold_phrase,
-        error_phrase=cfg.error_phrase,
-        command_handler=router.handle_command,
-        stream_text=router.stream_text if cfg.stream_tts else None,
-        stream_speak=stream_speak if cfg.stream_tts else None,
-        hold_phrase_for=router.describe_hold,
-        answer_to_template=phrases_for(cfg.stt_language)["answer_to"],
-        drain_delegations=router.drain_delegations,
-        deliver=router.deliver_answer if cfg.announce_mode == "signal" else None,
-    )
-    link = SatelliteLink(cfg, pipeline)
-    router.player = link.play_media   # deterministic music: "spiel Musik/Radio …"
-    # Pre-warm the local model so the FIRST question after a quiet hour answers instantly.
-    for brain in getattr(router, "_brains", {}).values():
-        if isinstance(brain, OllamaBrain):
-            asyncio.ensure_future(brain.warmup())
-
-    async def barge_in() -> None:
-        await server.interrupt_streams()
-        await link.stop_playback()
-
-    link.on_wake = barge_in
-    try:
-        await link.run_forever()
-    finally:
-        await server.stop()
-        await router.close()
-        await http.close()
-
-
-def main() -> None:
-    asyncio.run(run())
-
-
-if __name__ == "__main__":
-    main()
diff --git a/clients/voice-gateway/memex_voice_gateway/config.py b/clients/voice-gateway/memex_voice_gateway/config.py
deleted file mode 100644
index 15023b4c47..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/config.py
+++ /dev/null
@@ -1,227 +0,0 @@
-"""Gateway configuration — one flat dataclass, filled from environment variables.
-
-Three pluggable legs, each independently local or mesh-hosted:
-
-  BRAIN=memex   agent threads over /mcp (needs MEMEX_TOKEN + MEMEX_NAMESPACE)   [default]
-  BRAIN=ollama  a local model via Ollama (OLLAMA_URL / OLLAMA_MODEL)
-
-  STT_URL       full transcription endpoint. Default: {MEMEX_URL}/api/speech/transcribe.
-                Point it at a local whisper.cpp server instead (http://127.0.0.1:8090/inference)
-                — both speak multipart file+language → {"text": …}.
-
-  TTS_ENGINE=piper  the Piper CLI (container default)
-  TTS_ENGINE=say    macOS's built-in `say` (zero setup on a Mac; SAY_VOICE, e.g. "Anna")
-"""
-
-from __future__ import annotations
-
-import os
-from dataclasses import dataclass, field
-
-
-def _env(name: str, default: str | None = None) -> str | None:
-    value = os.environ.get(name, default)
-    return value if value not in ("", None) else default
-
-
-def _keychain(service: str) -> str | None:
-    """A secret from the macOS keychain — tokens never ride in env files or chat."""
-    import subprocess
-    try:
-        out = subprocess.run(["security", "find-generic-password", "-s", service, "-w"],
-                             capture_output=True, text=True, timeout=5)
-        return out.stdout.strip() or None
-    except Exception:
-        return None
-
-
-# What the SPEAKER says in its own voice (holding, errors, switch confirmations) — chosen by
-# the configured language; every instruction and prompt in this repo stays English.
-PHRASES: dict[str, dict[str, str]] = {
-    "en": {"hold": "Let me check. One moment please.",
-           "error": "Sorry, that did not work.",
-           "connected": "Connected to {name}.",
-           "unknown": "I don't know {target}. Available: {names}.",
-           "delegated": "Started a {agent} thread on {portal}. You can review it there.",
-           "no_mesh": "No mesh portal is configured for threads.",
-           "new_topic": "Okay, new topic.",
-           "switched": "Now in the thread about {topic}.",
-           "posted": "Posted to the thread about {topic}. I will announce the answer.",
-           "no_thread": "I have no open thread about {topic}.",
-           "threads_open": "Open threads: {list}.",
-           "no_threads": "No open threads.",
-           "ready": "The answer about {topic} is ready. Say: read it.",
-           "nothing_new": "No new answers.",
-           "radio_on": "Here comes {station}. Say stop to end it.",
-           "song_hint": "I cannot play single songs yet — but here comes {station}.",
-           "no_stations": "No radio stations are set up yet — add them under Voice, Station in the portal.",
-           "playing_song": "Here comes {title} by {artist}."},
-    "de": {"hold": "Ich schaue nach. Einen Moment bitte.",
-           "error": "Entschuldigung, das hat gerade nicht geklappt.",
-           "connected": "Verbunden mit {name}.",
-           "unknown": "Ich kenne {target} nicht. Verfügbar: {names}.",
-           "delegated": "Thread mit {agent} auf {portal} gestartet. Du kannst ihn dort anschauen.",
-           "no_mesh": "Es ist kein Portal für Threads konfiguriert.",
-           "new_topic": "Okay, neues Thema.",
-           "switched": "Wir sind jetzt im Thread über {topic}.",
-           "posted": "An den Thread über {topic} geschickt. Ich melde mich mit der Antwort.",
-           "no_thread": "Ich habe keinen offenen Thread über {topic}.",
-           "threads_open": "Offene Threads: {list}.",
-           "no_threads": "Keine offenen Threads.",
-           "ready": "Die Antwort zu {topic} ist bereit. Sag: vorlesen.",
-           "nothing_new": "Keine neuen Antworten.",
-           "radio_on": "Hier kommt {station}. Sag Stopp, wenn es reicht.",
-           "song_hint": "Einzelne Lieder kann ich noch nicht spielen — dafür kommt {station}.",
-           "no_stations": "Es sind noch keine Radiosender eingerichtet — füge sie im Portal unter Voice, Station hinzu.",
-           "playing_song": "Hier kommt {title} von {artist}."},
-}
-PHRASES["en"]["answer_to"] = "Answering your question: {question} —"
-PHRASES["de"]["answer_to"] = "Antwort auf deine Frage: {question} —"
-
-
-def phrases_for(language: str) -> dict[str, str]:
-    return PHRASES.get((language or "en").split("-")[0].lower(), PHRASES["en"])
-
-
-@dataclass
-class Config:
-    # --- the satellite (ESPHome native API, LAN) ---
-    satellite_host: str = ""
-    satellite_port: int = 6053
-    satellite_psk: str | None = None        # noise encryption key (preferred)
-    satellite_password: str | None = None   # legacy plaintext API password
-
-    # --- the brain ---
-    brain: str = "memex"                    # "memex" (agent threads) | "ollama" (local model)
-    memex_url: str = "https://memex.meshweaver.cloud"
-    memex_token: str = ""                   # mw_… API token (Settings ▸ Security ▸ API Tokens)
-    namespace: str = ""                     # thread namespace, e.g. your user id
-    agent: str | None = "Voice"             # lean spoken-answer agent; None = platform default
-    ollama_url: str = "http://127.0.0.1:11434"
-    ollama_model: str = "qwen3.6"
-
-    # --- speech-to-text ---
-    stt_url: str = ""                       # default derived: {memex_url}/api/speech/transcribe
-    stt_token: str | None = None            # bearer for the STT endpoint; None = unauthenticated
-    stt_language: str = "de"                # "de" transcribes Swiss German OUT as Standard German
-    sample_rate: int = 16000                # the satellite streams 16 kHz mono s16le
-
-    # --- conversation pacing ---
-    reply_budget_s: float = 10.0            # wait this long for the answer before acking
-    announce_budget_s: float = 1800.0       # keep polling this long — memex is ASYNC, real
-                                            # work takes minutes; the poll backs off to 10s
-    announce_mode: str = "signal"           # "signal": chime + mailbox, answer on "vorlesen";
-                                            # "full": speak the whole answer unprompted
-    thread_idle_minutes: float = 5.0        # reuse the conversation within this window
-    hold_phrase: str = ""                   # default: PHRASES[stt_language]["hold"]
-    error_phrase: str = ""                  # default: PHRASES[stt_language]["error"]
-
-    # --- multiple brains (optional) — see router.py; overrides the single-brain fields ---
-    portals: list = field(default_factory=list)   # PORTALS: JSON list of named targets
-
-    # --- wake word (activated on the device if none is) ---
-    wake_word: str = "hey_jarvis"           # micro-wake-word model id on the device
-    continue_conversation: bool = True      # after a reply, listen again without a wake word
-    speak_dialect: bool = False             # experiment: model writes Swiss German for the TTS
-    location: str | None = None             # where the speaker is (weather/'here' questions)
-    system_prompt_file: str | None = None   # override the built-in voice prompt with a file
-
-    # --- Home Assistant (optional) — a tool for the local brain, not a voice owner ---
-    ha_url: str | None = None               # e.g. http://homeassistant.local:8123
-    ha_token: str | None = None             # long-lived access token
-
-    # --- Music Assistant (optional) — songs/playlists via THEIR tooling (Spotify, Apple
-    # Music, Radio Browser providers); token from MA_TOKEN or the keychain entry
-    # `music-assistant-token` ---
-    ma_url: str = "http://127.0.0.1:8095"
-    ma_token: str | None = None
-
-    # --- the spoken session (context cookie) + tool reach ---
-    session_file: str = "~/.memex-voice/session.json"   # persisted context, per speaker
-    session_ttl_h: float = 8.0              # like an MCP session id: resumes within, expires after
-    allow_destructive: bool = False         # let mesh_tool reach delete/restore (default: never)
-
-    # --- endpointing (energy VAD) ---
-    silence_ms: int = 800
-    max_utterance_s: float = 15.0
-    min_utterance_s: float = 0.4
-
-    # --- text-to-speech + the URL the satellite fetches audio from ---
-    tts_engine: str = "piper"               # "piper" | "say" (macOS)
-    stream_tts: bool = False
-    record_dir: str | None = None           # save each round's raw utterance WAV here — the
-                                            # corpus for retraining the wake word on REAL voices                # chunked live TTS; OFF: ESPHome 2026's player
-                                            # aborts chunked bodies after ~200 bytes — replies
-                                            # ship as complete WAVs until device-verified
-    piper_bin: str = "piper"
-    piper_voice: str = "/voices/de_DE-thorsten-medium.onnx"
-    say_voice: str = "Anna"                 # macOS German voice
-    gateway_host: str = ""                  # LAN IP of THIS gateway, reachable by the satellite
-    gateway_port: int = 8200
-
-    extra: dict = field(default_factory=dict)
-
-    @staticmethod
-    def from_env() -> "Config":
-        import json
-        portals_raw = _env("PORTALS")
-        portals = json.loads(portals_raw) if portals_raw else []
-        memex_url = (_env("MEMEX_URL", "https://memex.meshweaver.cloud") or "").rstrip("/")
-        memex_token = _env("MEMEX_TOKEN") or ""
-        stt_url = _env("STT_URL") or f"{memex_url}/api/speech/transcribe"
-        # The mesh endpoint needs the bearer; a local whisper.cpp server does not.
-        stt_token = _env("STT_TOKEN") or (memex_token if stt_url.startswith(memex_url) else None)
-        cfg = Config(
-            satellite_host=_env("SATELLITE_HOST") or "",
-            satellite_port=int(_env("SATELLITE_PORT", "6053")),
-            satellite_psk=_env("SATELLITE_PSK"),
-            satellite_password=_env("SATELLITE_PASSWORD"),
-            brain=(_env("BRAIN", "memex") or "memex").lower(),
-            memex_url=memex_url,
-            memex_token=memex_token,
-            namespace=_env("MEMEX_NAMESPACE") or "",
-            agent=_env("MEMEX_AGENT", "Voice"),
-            ollama_url=(_env("OLLAMA_URL", "http://127.0.0.1:11434") or "").rstrip("/"),
-            ollama_model=_env("OLLAMA_MODEL", "qwen3.6") or "qwen3.6",
-            stt_url=stt_url,
-            stt_token=stt_token,
-            stt_language=_env("STT_LANGUAGE", "de") or "de",
-            reply_budget_s=float(_env("REPLY_BUDGET_S", "10")),
-            announce_budget_s=float(_env("ANNOUNCE_BUDGET_S", "1800")),
-            announce_mode=(_env("ANNOUNCE_MODE", "signal") or "signal").lower(),
-            thread_idle_minutes=float(_env("THREAD_IDLE_MINUTES", "5")),
-            hold_phrase=_env("HOLD_PHRASE") or phrases_for(_env("STT_LANGUAGE", "de") or "de")["hold"],
-            error_phrase=_env("ERROR_PHRASE") or phrases_for(_env("STT_LANGUAGE", "de") or "de")["error"],
-            wake_word=_env("WAKE_WORD", "hey_jarvis") or "hey_jarvis",
-            continue_conversation=(_env("CONTINUE_CONVERSATION", "true") or "true").lower() != "false",
-            speak_dialect=(_env("SPEAK_DIALECT", "false") or "false").lower() == "true",
-            location=_env("LOCATION"),
-            system_prompt_file=_env("SYSTEM_PROMPT_FILE"),
-            ha_url=(_env("HA_URL") or "").rstrip("/") or None,
-            ha_token=_env("HA_TOKEN"),
-            ma_url=(_env("MA_URL", Config.ma_url) or Config.ma_url).rstrip("/"),
-            ma_token=_env("MA_TOKEN") or _keychain("music-assistant-token"),
-            session_file=_env("SESSION_FILE", Config.session_file) or Config.session_file,
-            session_ttl_h=float(_env("SESSION_TTL_H", "8")),
-            allow_destructive=(_env("ALLOW_DESTRUCTIVE", "false") or "false").lower() == "true",
-            silence_ms=int(_env("SILENCE_MS", "800")),
-            tts_engine=(_env("TTS_ENGINE", "piper") or "piper").lower(),
-            stream_tts=(_env("STREAM_TTS", "false") or "false").lower() == "true",
-            record_dir=_env("RECORD_DIR"),
-            piper_bin=_env("PIPER_BIN", "piper") or "piper",
-            piper_voice=_env("PIPER_VOICE", Config.piper_voice) or Config.piper_voice,
-            say_voice=_env("SAY_VOICE", "Anna") or "Anna",
-            gateway_host=_env("GATEWAY_HOST") or "",
-            gateway_port=int(_env("GATEWAY_PORT", "8200")),
-            sample_rate=int(_env("SAMPLE_RATE", "16000")),
-            portals=portals,
-        )
-        required = [("SATELLITE_HOST", cfg.satellite_host), ("GATEWAY_HOST", cfg.gateway_host)]
-        if not cfg.portals and cfg.brain == "memex":
-            required += [("MEMEX_TOKEN", cfg.memex_token), ("MEMEX_NAMESPACE", cfg.namespace)]
-        missing = [name for name, value in required if not value]
-        if missing:
-            raise SystemExit(f"Missing required environment variables: {', '.join(missing)}")
-        if cfg.brain not in ("memex", "ollama"):
-            raise SystemExit(f"BRAIN must be 'memex' or 'ollama', not '{cfg.brain}'")
-        return cfg
diff --git a/clients/voice-gateway/memex_voice_gateway/homeassistant.py b/clients/voice-gateway/memex_voice_gateway/homeassistant.py
deleted file mode 100644
index 6839e4bf6a..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/homeassistant.py
+++ /dev/null
@@ -1,81 +0,0 @@
-"""A thin Home Assistant REST client, exposed to the local brain as ONE tool.
-
-The gateway keeps the satellite's voice subscription (the ESPHome voice pipeline has one
-owner); Home Assistant rides alongside as a tool — lights, switches, scenes, media — via
-its long-lived-access-token REST API. Configure with HA_URL + HA_TOKEN; absent, the tool
-is simply not offered.
-"""
-
-from __future__ import annotations
-
-import aiohttp
-
-_LIST_LIMIT = 40
-
-
-class HomeAssistant:
-    def __init__(self, base_url: str, token: str) -> None:
-        self.base_url = base_url.rstrip("/")
-        self._headers = {"Authorization": f"Bearer {token}"}
-        self._http: aiohttp.ClientSession | None = None
-
-    async def _session(self) -> aiohttp.ClientSession:
-        if self._http is None:
-            self._http = aiohttp.ClientSession(headers=self._headers)
-        return self._http
-
-    async def run(self, args: dict) -> str:
-        action = str(args.get("action", "")).strip()
-        if action == "list_entities":
-            return await self._list_entities(str(args.get("domain", "")).strip())
-        if action == "get_state":
-            return await self._get_state(str(args.get("entity_id", "")).strip())
-        if action == "call_service":
-            return await self._call_service(str(args.get("domain", "")).strip(),
-                                            str(args.get("service", "")).strip(),
-                                            str(args.get("entity_id", "")).strip())
-        return f"Unknown action: {action!r}. Use list_entities, get_state, or call_service."
-
-    async def _list_entities(self, domain: str) -> str:
-        http = await self._session()
-        async with http.get(f"{self.base_url}/api/states") as response:
-            response.raise_for_status()
-            states = await response.json()
-        rows = [f"{s['entity_id']}: {s.get('state')}"
-                f" ({(s.get('attributes') or {}).get('friendly_name', '')})"
-                for s in states
-                if not domain or s["entity_id"].startswith(domain + ".")]
-        if not rows:
-            return f"No entities{f' in domain {domain}' if domain else ''}."
-        clipped = rows[:_LIST_LIMIT]
-        more = f" …and {len(rows) - len(clipped)} more" if len(rows) > len(clipped) else ""
-        return "\n".join(clipped) + more
-
-    async def _get_state(self, entity_id: str) -> str:
-        if not entity_id:
-            return "entity_id is required for get_state."
-        http = await self._session()
-        async with http.get(f"{self.base_url}/api/states/{entity_id}") as response:
-            if response.status == 404:
-                return f"No entity {entity_id}."
-            response.raise_for_status()
-            state = await response.json()
-        attrs = state.get("attributes") or {}
-        name = attrs.get("friendly_name", entity_id)
-        return f"{name} is {state.get('state')}."
-
-    async def _call_service(self, domain: str, service: str, entity_id: str) -> str:
-        if not (domain and service):
-            return "domain and service are required for call_service."
-        http = await self._session()
-        payload = {"entity_id": entity_id} if entity_id else {}
-        async with http.post(f"{self.base_url}/api/services/{domain}/{service}",
-                             json=payload) as response:
-            if response.status >= 400:
-                return f"Home Assistant refused {domain}.{service}: HTTP {response.status}."
-        return f"Done: {domain}.{service}" + (f" on {entity_id}." if entity_id else ".")
-
-    async def close(self) -> None:
-        if self._http is not None:
-            await self._http.close()
-            self._http = None
diff --git a/clients/voice-gateway/memex_voice_gateway/musicassistant.py b/clients/voice-gateway/memex_voice_gateway/musicassistant.py
deleted file mode 100644
index 90a19a97a6..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/musicassistant.py
+++ /dev/null
@@ -1,77 +0,0 @@
-"""Music Assistant — the household's OWN music tooling, spoken to over its WebSocket API.
-
-MA is the executor for everything beyond plain radio-station URLs: its providers (Spotify,
-Apple Music, Radio Browser, …) resolve songs, artists and stations, and its players play
-them. This client only RESOLVES and DELEGATES — it never re-implements a music service.
-Configure with MA_URL + an API token (created in MA's settings after login, stored in the
-keychain as `music-assistant-token`); absent, music stays radio-URLs-only.
-"""
-
-from __future__ import annotations
-
-import itertools
-import json
-import logging
-
-import aiohttp
-
-logger = logging.getLogger(__name__)
-
-
-class MusicAssistant:
-    def __init__(self, base_url: str, token: str) -> None:
-        self.base_url = base_url.rstrip("/")
-        self._token = token
-        self._http: aiohttp.ClientSession | None = None
-        self._ws: aiohttp.ClientWebSocketResponse | None = None
-        self._ids = itertools.count(1)
-
-    async def _ensure(self) -> None:
-        if self._ws is not None and not self._ws.closed:
-            return
-        if self._http is None:
-            self._http = aiohttp.ClientSession()
-        self._ws = await self._http.ws_connect(f"{self.base_url}/ws", timeout=10)
-        await self._ws.receive(timeout=5)          # server-info greeting
-        reply = await self._cmd_raw("auth", token=self._token)
-        if reply.get("error_code"):
-            raise RuntimeError(f"Music Assistant auth failed: {reply.get('details')}")
-
-    async def _cmd_raw(self, command: str, **args) -> dict:
-        message_id = str(next(self._ids))
-        assert self._ws is not None
-        await self._ws.send_json({"message_id": message_id, "command": command, "args": args})
-        while True:
-            msg = json.loads((await self._ws.receive(timeout=30)).data)
-            if msg.get("message_id") == message_id:
-                return msg
-
-    async def cmd(self, command: str, **args):
-        await self._ensure()
-        reply = await self._cmd_raw(command, **args)
-        if reply.get("error_code"):
-            raise RuntimeError(f"{command}: {reply.get('details')}")
-        return reply.get("result")
-
-    async def search(self, query: str, media_types: list[str] | None = None,
-                     limit: int = 8) -> dict:
-        """MA-wide search across all configured providers. Returns MA's results object
-        (keys per media type: tracks, artists, radio, …)."""
-        return await self.cmd("music/search", search_query=query,
-                              media_types=media_types or ["track", "radio", "playlist"],
-                              limit=limit)
-
-    async def players(self) -> list[dict]:
-        return list(await self.cmd("players/all") or [])
-
-    async def play(self, uri: str, queue_id: str) -> None:
-        """Hand the resolved item to MA's own playback (its providers stream it)."""
-        await self.cmd("player_queues/play_media", queue_id=queue_id, media=uri)
-
-    async def close(self) -> None:
-        if self._ws is not None:
-            await self._ws.close()
-            self._ws = None
-        if self._http is not None:
-            await self._http.close()
-            self._http = None
diff --git a/clients/voice-gateway/memex_voice_gateway/ollama.py b/clients/voice-gateway/memex_voice_gateway/ollama.py
deleted file mode 100644
index b99cb0c964..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/ollama.py
+++ /dev/null
@@ -1,369 +0,0 @@
-"""A local model as the brain, via Ollama's /api/chat.
-
-Implements the same two-phase surface as MemexThreads (`ask` → handle, `await_reply` with a
-budget), so the pipeline — including the holding-phrase + announce path — is identical for a
-local model and a mesh agent. Generation runs in a background task; a budget miss leaves it
-running and the announce poll picks the answer up when it lands.
-
-Conversation history lives in-process (this brain has no thread node) and resets after the
-same idle window a mesh thread would.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import itertools
-import time
-from dataclasses import dataclass, field
-
-import aiohttp
-
-SYSTEM_PROMPT = (
-    "You are Memex, the on-device voice of the user's personal mesh — when asked who you "
-    "are, your name is Memex. Everything you write is read aloud by text-to-speech: at most "
-    "two short sentences, no markdown, lists, code, or links. Reply in the language you were "
-    "addressed in; Swiss German arrives transcribed as Standard German — reply in Standard "
-    "German. Say numbers and dates in speakable words. Each user message starts with its "
-    "wall-clock time in brackets — use it to judge gaps in the conversation.\n\n"
-    "TRIAGE — decide per request: answer DIRECTLY yourself for time, dates, general "
-    "knowledge, conversions, and small talk (you run on-device; speed is your virtue). "
-    "For a QUICK lookup use your tools: search_mesh finds nodes in the user's mesh, "
-    "get_node reads one, mesh_tool calls any other portal tool by name, home_assistant "
-    "controls the smart home. DELEGATE by calling "
-    "delegate_to_memex — it opens a thread in the mesh where a full agent with its own "
-    "tools works the task — for anything that needs current information from the web, "
-    "documents, writing or changing data, or multi-step work. Anything about EMAIL — "
-    "reading, summarizing, or sending mail — always delegates to the ExecutiveAssistant "
-    "agent: it acts on the user's own mailbox and calendar. NEVER claim you cannot access "
-    "email and NEVER tell the user to open a mail program — delegate instead. After "
-    "delegating, tell the user in ONE sentence that Memex is on it and will announce the "
-    "answer.\n\n"
-    "You never lack capability: whatever you cannot do on-device, the mesh can. Whenever "
-    "you think 'I cannot do that', that is EXACTLY when to call delegate_to_memex — never "
-    "refuse, never apologize for missing abilities, never send the user to another app.\n\n"
-    "Small talk, greetings, and questions about yourself or the speaker get a DIRECT "
-    "answer — never a tool call. Children talk to you too: stay warm, simple, and honest — "
-    "never invent an agent, a capability, or a promise you cannot keep this instant."
-)
-
-_WEEKDAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
-_MONTHS = ["January", "February", "March", "April", "May", "June", "July",
-           "August", "September", "October", "November", "December"]
-
-
-def now_line(now=None) -> str:
-    """The current wall-clock — a local model has NO clock of its own, and a voice
-    assistant unmoored from real time answers 'today' questions wrongly. Model-facing, so
-    English regardless of the spoken language."""
-    import datetime
-    now = now or datetime.datetime.now().astimezone()
-    return (f"Current time: {_WEEKDAYS[now.weekday()]}, {now.day} "
-            f"{_MONTHS[now.month - 1]} {now.year}, {now:%H:%M}.")
-
-
-def build_messages(history: list[dict], text: str, system_prompt: str = SYSTEM_PROMPT,
-                   max_turns: int = 8, now: str | None = None) -> list[dict]:
-    """System prompt (+ the real-time anchor) + the last `max_turns` exchanges + the new
-    user message. History user entries carry their [HH:MM] stamps from ask()."""
-    system = system_prompt if now is None else f"{system_prompt}\n\n{now}"
-    trimmed = history[-2 * max_turns:]
-    return [{"role": "system", "content": system}, *trimmed,
-            {"role": "user", "content": text}]
-
-
-# The standard agents offered for delegation — extended/overridden per deployment
-# (a portal entry's "agents" list adds names AND pins where each one runs).
-DEFAULT_AGENTS = {
-    "Voice": "quick data lookups",
-    "Assistant": "general work",
-    "Researcher": "deep research",
-    "ExecutiveAssistant": "EMAIL — reading, summarizing, and sending mail",
-    "Music": "playing specific songs, artists and playlists via the connected music "
-             "services (Spotify, Apple Music)",
-}
-
-
-def delegate_tool(agents: dict[str, str] | None = None) -> dict:
-    """The delegate_to_memex spec, its agent enum built from the CONFIGURED roster."""
-    roster = agents or DEFAULT_AGENTS
-    return {
-        "type": "function",
-        "function": {
-            "name": "delegate_to_memex",
-            "description": "Open a THREAD in the user's mesh, where a full agent with its "
-                           "own system prompt and tools (their data, web search, documents, "
-                           "email) works the task. The answer is announced when ready.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "task": {"type": "string", "description": "The task, self-contained, in the user's language."},
-                    "agent": {"type": "string", "enum": list(roster),
-                              "description": " ".join(f"{n}: {d}." for n, d in roster.items())},
-                },
-                "required": ["task"],
-            },
-        },
-    }
-
-
-DELEGATE_TOOL = delegate_tool()
-
-# The normal read-only tools every mesh client has — run in-round by the router against the
-# active/first mesh portal, so a quick lookup never costs a whole thread.
-MESH_TOOLS = [
-    {"type": "function", "function": {
-        "name": "search_mesh",
-        "description": "Search the user's mesh (notes, documents, courses, data). Returns "
-                       "matching nodes with their paths. Free text works; so do filters "
-                       "like nodeType:Agent or name:*sales*.",
-        "parameters": {"type": "object", "properties": {
-            "query": {"type": "string", "description": "Free text or GitHub-style query."}},
-            "required": ["query"]},
-    }},
-    {"type": "function", "function": {
-        "name": "get_node",
-        "description": "Read one mesh node by path (as returned by search_mesh), e.g. "
-                       "@Doc/Architecture/Plugins.",
-        "parameters": {"type": "object", "properties": {
-            "path": {"type": "string", "description": "The node path, e.g. @Edu/Guide."}},
-            "required": ["path"]},
-    }},
-]
-
-# FULL MCP: any tool on the connected portal, by name — the same surface an MCP client
-# has. Destructive tools are filtered router-side unless explicitly enabled.
-MESH_TOOL = {
-    "type": "function",
-    "function": {
-        "name": "mesh_tool",
-        "description": "Call ANY tool on the user's mesh portal by its MCP name — e.g. "
-                       "autocomplete, render_area, navigate_to, create, update, "
-                       "execute_script. Use search_mesh/get_node for plain lookups; use "
-                       "this for everything else the portal offers.",
-        "parameters": {"type": "object", "properties": {
-            "tool": {"type": "string", "description": "The MCP tool name, e.g. render_area."},
-            "arguments": {"type": "object", "description": "The tool's arguments object."},
-        }, "required": ["tool"]},
-    },
-}
-
-HOME_TOOL = {
-    "type": "function",
-    "function": {
-        "name": "home_assistant",
-        "description": "Control or read the smart home via Home Assistant: list entities, "
-                       "read a state, or call a service (turn_on, turn_off, toggle, ...).",
-        "parameters": {"type": "object", "properties": {
-            "action": {"type": "string", "enum": ["list_entities", "get_state", "call_service"]},
-            "entity_id": {"type": "string", "description": "e.g. light.living_room"},
-            "domain": {"type": "string", "description": "service domain, e.g. light, switch, media_player"},
-            "service": {"type": "string", "description": "e.g. turn_on, turn_off, toggle"},
-        }, "required": ["action"]},
-    },
-}
-
-_TOOL_RESULT_LIMIT = 1500   # a small on-device model drowns in a full search dump
-
-
-@dataclass
-class OllamaBrain:
-    base_url: str
-    model: str
-    idle_minutes: float = 5.0
-    num_predict: int = 200
-    system_prompt: str = SYSTEM_PROMPT
-    location: str | None = None    # anchors 'here'/weather questions to a real place
-    # The triage seams, set by the router: delegator(task, agent) -> stamped handle OPENS A
-    # THREAD in the mesh (the pipeline drains pending delegations and announces their
-    # answers); tool_runner(name, args) -> str runs the quick read-only tools in-round.
-    delegator: object = None
-    tool_runner: object = None
-    tools: list = field(default_factory=list)   # specs offered alongside delegate_to_memex
-    agents: dict | None = None                  # delegation roster: name → description
-    _pending: list = field(default_factory=list, init=False)
-
-    _history: list[dict] = field(default_factory=list, init=False)
-    _last_used: float = field(default=0.0, init=False)
-    _tasks: dict[str, asyncio.Task] = field(default_factory=dict, init=False)
-    _chunks: dict[str, asyncio.Queue] = field(default_factory=dict, init=False)
-    _ids: itertools.count = field(default_factory=itertools.count, init=False)
-    _http: aiohttp.ClientSession | None = field(default=None, init=False)
-
-    async def _chat(self, messages: list[dict], handle: str | None = None) -> str:
-        """One completion; when `handle` names a chunk queue, STREAM pieces into it as they
-        arrive — the voice pipeline speaks them sentence-by-sentence while generation runs."""
-        if handle is not None:
-            return await self._chat_streaming(messages, handle)
-        if self._http is None:
-            self._http = aiohttp.ClientSession()
-        # keep_alive holds the model in RAM between questions — without it, Ollama unloads
-        # after ~5 min idle and the next wake pays the full model load (measured: 15s cold
-        # vs 0.4s warm for qwen3.6 on an M5 Max).
-        payload = {"model": self.model, "messages": messages, "stream": False,
-                   "think": False, "keep_alive": "60m",
-                   "options": {"num_predict": self.num_predict}}
-        async with self._http.post(f"{self.base_url}/api/chat", json=payload,
-                                   timeout=aiohttp.ClientTimeout(total=300)) as response:
-            if response.status == 400:
-                # Older Ollama / non-thinking model rejecting "think" — retry without it.
-                del payload["think"]
-                async with self._http.post(f"{self.base_url}/api/chat", json=payload,
-                                           timeout=aiohttp.ClientTimeout(total=300)) as retry:
-                    retry.raise_for_status()
-                    data = await retry.json()
-            else:
-                response.raise_for_status()
-                data = await response.json()
-        return (data.get("message") or {}).get("content", "").strip()
-
-    async def _chat_streaming(self, messages: list[dict], handle: str) -> str:
-        if self._http is None:
-            self._http = aiohttp.ClientSession()
-        queue = self._chunks[handle]
-        pieces: list[str] = []
-        import json as _json
-        working = list(messages)
-        offered = list(self.tools) + (
-            [delegate_tool(self.agents)] if self.delegator is not None else [])
-        try:
-            for _round in range(3):   # tools on rounds 0-1; the LAST round must SPEAK —
-                # a child's "Wie heisse ich?" once sent the model tool-calling in circles
-                # until the cap killed the turn, and the spoken reply was the one word
-                # that dribbled out before the first call ("Du").
-                payload = {"model": self.model, "messages": working, "stream": True,
-                           "think": False, "keep_alive": "60m",
-                           "options": {"num_predict": self.num_predict}}
-                if offered and _round < 2:
-                    payload["tools"] = offered
-                tool_calls: list = []
-                async with self._http.post(f"{self.base_url}/api/chat", json=payload,
-                                           timeout=aiohttp.ClientTimeout(total=300)) as response:
-                    response.raise_for_status()
-                    async for line in response.content:
-                        if not line.strip():
-                            continue
-                        data = _json.loads(line)
-                        message = data.get("message") or {}
-                        piece = message.get("content", "")
-                        if piece:
-                            pieces.append(piece)
-                            await queue.put(piece)
-                        if message.get("tool_calls"):
-                            tool_calls.extend(message["tool_calls"])
-                        if data.get("done"):
-                            break
-                if not tool_calls:
-                    break
-                working.append({"role": "assistant", "content": "", "tool_calls": tool_calls})
-                for call in tool_calls:
-                    working.append({"role": "tool",
-                                    "content": await self._dispatch_tool(call)})
-        finally:
-            await queue.put(None)
-        return "".join(pieces).strip()
-
-    async def _dispatch_tool(self, call: dict) -> str:
-        """One tool call → its result string. delegate_to_memex OPENS A THREAD (via the
-        router's delegator) and queues the stamped handle for the announce path; everything
-        else runs through tool_runner, truncated to what a small model can digest."""
-        import json as _json
-        fn = (call.get("function") or {})
-        name = fn.get("name", "")
-        args = fn.get("arguments") or {}
-        if isinstance(args, str):
-            try: args = _json.loads(args)
-            except Exception: args = {"task": args} if name == "delegate_to_memex" else {}
-        if name == "delegate_to_memex":
-            if self.delegator is None:
-                return "Delegation is not configured."
-            task = str(args.get("task", "")).strip()
-            try:
-                stamped = await self.delegator(task, args.get("agent") or None)
-                self._pending.append((stamped, task))
-                return "Delegated: a memex thread is working on it. The answer will be announced."
-            except Exception as e:
-                return f"Delegation failed: {e}"
-        if self.tool_runner is None:
-            return f"Unknown tool: {name}"
-        try:
-            result = str(await self.tool_runner(name, args))
-        except Exception as e:
-            return f"Tool {name} failed: {e}"
-        if len(result) > _TOOL_RESULT_LIMIT:
-            result = result[:_TOOL_RESULT_LIMIT] + " …(truncated)"
-        return result
-
-    def drain_delegations(self) -> list:
-        """(stamped_handle, task) pairs the pipeline should announce answers for."""
-        pending, self._pending = self._pending, []
-        return pending
-
-    async def ask(self, text: str) -> str:
-        """Start generating; returns a handle usable with await_reply (pipeline contract)."""
-        if self._history and (time.monotonic() - self._last_used) > self.idle_minutes * 60:
-            self._history = []
-        self._last_used = time.monotonic()
-        import datetime
-        stamped = f"[{datetime.datetime.now().astimezone():%H:%M}] {text}"
-        anchor = now_line() + (f" Location: {self.location}." if self.location else "")
-        messages = build_messages(self._history, stamped, system_prompt=self.system_prompt,
-                                  now=anchor)
-        self._history.append({"role": "user", "content": stamped})
-
-        handle = f"ollama-{next(self._ids)}"
-        self._chunks[handle] = asyncio.Queue()
-
-        async def generate() -> str:
-            reply = await self._chat(messages, handle=handle)
-            self._history.append({"role": "assistant", "content": reply})
-            return reply
-
-        self._tasks[handle] = asyncio.create_task(generate())
-        return handle
-
-    def stream_text(self, handle: str):
-        """Async iterator over the reply's text pieces as they are generated, or None."""
-        queue = self._chunks.get(handle)
-        if queue is None:
-            return None
-
-        async def drain():
-            while (piece := await queue.get()) is not None:
-                yield piece
-            self._chunks.pop(handle, None)
-
-        return drain()
-
-    async def await_reply(self, handle: str, budget_s: float) -> str | None:
-        task = self._tasks.get(handle)
-        if task is None:
-            return None
-        try:
-            reply = await asyncio.wait_for(asyncio.shield(task), timeout=budget_s)
-        except asyncio.TimeoutError:
-            return None      # generation keeps running; the announce path retries this handle
-        self._tasks.pop(handle, None)
-        self._chunks.pop(handle, None)   # nobody streamed this round — drop the piece queue
-        return reply
-
-    async def warmup(self) -> None:
-        """Load the model into RAM before the first question — a cold 23GB MoE load reads
-        as the assistant ignoring you (measured: ~15-30s cold vs sub-second warm)."""
-        if self._http is None:
-            self._http = aiohttp.ClientSession()
-        try:
-            payload = {"model": self.model, "messages": [{"role": "user", "content": "hi"}],
-                       "stream": False, "think": False, "keep_alive": "60m",
-                       "options": {"num_predict": 1}}
-            async with self._http.post(f"{self.base_url}/api/chat", json=payload,
-                                       timeout=aiohttp.ClientTimeout(total=180)) as response:
-                await response.read()
-        except Exception:
-            pass   # warmup is best-effort; the first real question pays the load instead
-
-    async def close(self) -> None:
-        for task in self._tasks.values():
-            task.cancel()
-        if self._http is not None:
-            await self._http.close()
-            self._http = None
diff --git a/clients/voice-gateway/memex_voice_gateway/pipeline.py b/clients/voice-gateway/memex_voice_gateway/pipeline.py
deleted file mode 100644
index 7817b9de0e..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/pipeline.py
+++ /dev/null
@@ -1,194 +0,0 @@
-"""The voice round, orchestrated: audio → STT → thread → reply (now or announced later).
-
-Measured reality on memex (2026-08-18): a thread round takes ~60–70 s wall clock even for a
-trivial question — the time is dispatch/startup, not generation. So the pipeline's PRIMARY
-shape is: try to answer within `reply_budget_s`; on a miss, speak a short holding phrase, end
-the voice run (freeing the device), keep polling in the background, and deliver the real
-answer as an ANNOUNCEMENT when it lands. If the platform's dispatch latency improves, the
-same code simply starts answering inline.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from dataclasses import dataclass
-from typing import Awaitable, Callable
-
-logger = logging.getLogger(__name__)
-
-# Narrow protocol the satellite link implements — kept as callables so the pipeline is
-# unit-testable with plain fakes and never imports aioesphomeapi.
-SpeakFn = Callable[[str], Awaitable[str]]          # text -> served WAV url
-TranscribeFn = Callable[[bytes], Awaitable[str]]   # pcm  -> transcript
-
-
-import re
-
-# Whisper annotates non-speech as *Musik*, [Lachen], (Applaus) … — an utterance that is ONLY
-# such annotation is ambient noise, never a question. Answering it is how a TV becomes a
-# conversation partner through the WAKE path (observed: false wakes every ~10s, each round
-# transcribing its own or the TV's audio).
-_NOISE_ONLY = re.compile(r"^[\s\*\[\(]*[^\w]*[\wäöüéè' -]{0,40}?"
-                         r"(musik|lachen|applaus|geräusch|räusper|husten|"
-                         r"music|laughter|applause|noise|coughs?)"
-                         r"[^\w]*[\s\*\]\)]*$", re.IGNORECASE)
-
-
-def is_noise_transcript(transcript: str) -> bool:
-    stripped = transcript.strip()
-    if not stripped:
-        return True
-    if stripped.startswith(("*", "[", "(")) and stripped.endswith(("*", "]", ")")):
-        return True
-    return _NOISE_ONLY.match(stripped) is not None
-
-
-@dataclass
-class RoundResult:
-    transcript: str
-    reply: str | None      # None = budget missed, announcement pending
-    tts_url: str | None
-    interrupt: bool = False   # a spoken "stop": kill current playback, say nothing
-    noise: bool = False       # ambient/non-speech round: discarded without an answer
-
-
-class VoicePipeline:
-    def __init__(
-        self,
-        *,
-        transcribe: TranscribeFn,
-        ask: Callable[[str], Awaitable[str]],                 # text -> thread path
-        await_reply: Callable[[str, float], Awaitable[str | None]],
-        speak: SpeakFn,
-        announce: Callable[[str, str], Awaitable[None]],      # (url, text) -> None
-        reply_budget_s: float,
-        announce_budget_s: float,
-        hold_phrase: str,
-        error_phrase: str,
-        command_handler: Callable[[str], Awaitable[str | None]] | None = None,
-        stream_text: Callable[[str], object | None] | None = None,
-        stream_speak: Callable[[object], Awaitable[str]] | None = None,
-        hold_phrase_for: Callable[[str], str] | None = None,
-        answer_to_template: str | None = None,
-        drain_delegations: Callable[[], list] | None = None,
-        deliver: Callable[[str, str, str], str] | None = None,
-    ) -> None:
-        # deliver(handle, task, reply) -> the text to SPEAK when an async answer lands
-        # (signal mode: a short ready-chime; the full text waits for a spoken "vorlesen").
-        # None keeps the original behavior: announce the full answer immediately.
-        self._deliver = deliver
-        self._drain_delegations = drain_delegations
-        self._command_handler = command_handler
-        self._stream_text = stream_text
-        self._stream_speak = stream_speak
-        self._hold_phrase_for = hold_phrase_for
-        self._answer_to_template = answer_to_template
-        self._transcribe = transcribe
-        self._ask = ask
-        self._await_reply = await_reply
-        self._speak = speak
-        self._announce = announce
-        self._reply_budget_s = reply_budget_s
-        self._announce_budget_s = announce_budget_s
-        self._hold_phrase = hold_phrase
-        self._error_phrase = error_phrase
-        self._background: set[asyncio.Task] = set()
-
-    async def run(self, pcm: bytes) -> RoundResult:
-        """One voice round. Returns what to speak NOW; may schedule a later announcement."""
-        try:
-            transcript = await self._transcribe(pcm)
-        except Exception:
-            logger.exception("STT failed")
-            return RoundResult("", self._error_phrase, await self._try_speak(self._error_phrase))
-        if is_noise_transcript(transcript):
-            logger.info("noise round discarded: %r", transcript[:60])
-            return RoundResult(transcript, None, None, noise=True)
-
-        # Control commands (e.g. "wechsle zu systemorph") are handled deterministically,
-        # before any brain sees the text — the handler's confirmation is spoken directly.
-        if self._command_handler is not None:
-            confirmation = await self._command_handler(transcript)
-            if confirmation == "":
-                return RoundResult(transcript, None, None, interrupt=True)  # spoken "stop"
-            if confirmation is not None:
-                # A spoken post-to-thread queues its announcement like any delegation.
-                self._schedule_delegations()
-                return RoundResult(transcript, confirmation,
-                                   await self._try_speak(confirmation))
-
-        try:
-            thread_path = await self._ask(transcript)
-
-            # Streaming path: a brain that streams text + a streaming TTS session mean the
-            # device starts PLAYING while generation is still running — the URL blocks until
-            # the first spoken sentence lands, then sentences flow as the model writes them.
-            if self._stream_text is not None and self._stream_speak is not None:
-                chunks = self._stream_text(thread_path)
-                if chunks is not None:
-                    url = await self._stream_speak(chunks)
-                    logger.info("round: %r → streaming reply", transcript)
-                    return RoundResult(transcript, None, url)
-
-            reply = await self._await_reply(thread_path, self._reply_budget_s)
-        except Exception:
-            logger.exception("thread submission failed")
-            return RoundResult(transcript, self._error_phrase,
-                               await self._try_speak(self._error_phrase))
-        logger.info("round: %r → %r", transcript, (reply or "")[:120])
-
-        # The local brain may have TRIAGED work to the mesh mid-round: schedule the
-        # announcement of each delegated thread's answer, attributed to its task.
-        self._schedule_delegations()
-
-        if reply is not None:
-            return RoundResult(transcript, reply, await self._try_speak(reply))
-
-        # Budget missed: acknowledge the SUBMISSION (naming the portal — answers can be
-        # highly async), and deliver the real answer later, prefixed with which question it
-        # belongs to, so out-of-order arrivals stay attributable.
-        task = asyncio.create_task(self._announce_when_ready(thread_path, transcript))
-        self._background.add(task)
-        task.add_done_callback(self._background.discard)
-        hold = (self._hold_phrase_for(thread_path) if self._hold_phrase_for
-                else self._hold_phrase)
-        return RoundResult(transcript, None, await self._try_speak(hold))
-
-    def _schedule_delegations(self) -> None:
-        if self._drain_delegations is None:
-            return
-        for handle, task in self._drain_delegations():
-            delegated = asyncio.create_task(self._announce_when_ready(handle, task))
-            self._background.add(delegated)
-            delegated.add_done_callback(self._background.discard)
-
-    async def _announce_when_ready(self, thread_path: str, transcript: str) -> None:
-        try:
-            reply = await self._await_reply(thread_path, self._announce_budget_s)
-            if reply is None:
-                logger.warning("no answer within %.0fs for %r (%s)",
-                               self._announce_budget_s, transcript[:60], thread_path)
-                reply = self._error_phrase
-            elif self._deliver is not None:
-                # Mailbox mode: store the answer, speak only the short READY signal.
-                signal = self._deliver(thread_path, transcript, reply)
-                logger.info("answer ready for %r (%s) — signalling", transcript[:60], thread_path)
-                url = await self._speak(signal)
-                await self._announce(url, signal)
-                return
-            if self._answer_to_template:
-                question = transcript if len(transcript) <= 60 else transcript[:57] + "…"
-                reply = f"{self._answer_to_template.format(question=question)} {reply}"
-            logger.info("announcing answer for %r (%s)", transcript[:60], thread_path)
-            url = await self._speak(reply)
-            await self._announce(url, reply)
-        except Exception:
-            logger.exception("late announcement failed")
-
-    async def _try_speak(self, text: str) -> str | None:
-        try:
-            return await self._speak(text)
-        except Exception:
-            logger.exception("TTS failed")
-            return None
diff --git a/clients/voice-gateway/memex_voice_gateway/router.py b/clients/voice-gateway/memex_voice_gateway/router.py
deleted file mode 100644
index 3b0ffea934..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/router.py
+++ /dev/null
@@ -1,574 +0,0 @@
-"""Multiple brains, one wake word — and a spoken command to switch between them.
-
-`PORTALS` (JSON) declares a named list of targets — mesh portals (memex, systemorph, a
-customer instance) and/or a local model:
-
-    PORTALS='[
-      {"name":"memex","url":"https://memex.meshweaver.cloud","token":"mw_…","namespace":"rbuergi","agent":"Voice"},
-      {"name":"systemorph","url":"https://memex.systemorph.com","token":"mw_…","namespace":"rbuergi","agent":"Voice"},
-      {"name":"lokal","kind":"ollama","model":"qwen3.6"}
-    ]'
-
-Switching is a DETERMINISTIC spoken command matched before the brain ever sees the text
-("switch to systemorph", "wechsle zu memex", "verbinde mit lokal", "gang uf systemorph") —
-regex, not a tool call, so it works identically on every brain and cannot be mis-refused
-by a model. The confirmation is spoken back; everything else flows to the ACTIVE brain.
-"""
-
-from __future__ import annotations
-
-import re
-from typing import Awaitable, Callable, Protocol
-
-
-class Brain(Protocol):
-    async def ask(self, text: str) -> str: ...
-    async def await_reply(self, handle: str, budget_s: float) -> str | None: ...
-    async def close(self) -> None: ...
-
-
-_STOP = re.compile(r"^\s*(?:stop|stopp|halt|sei still|ruhe|schweig|genug)[.!]?\s*$", re.IGNORECASE)
-
-# Courteous closure is the END of an exchange, not a prompt: answering "Vielen Dank" with
-# "Gerne geschehen!" made the device hear its own reply (or the TV's politeness) and wake
-# again — a self-thanking loop, five rounds in 90 seconds, observed live.
-# A wake-word chant ("hey memex hey memex …") is a TRAINING RECORDING, not a question —
-# record it (the satellite already has), answer nothing.
-_CHANT = re.compile(r"^\s*(?:hey,?\s*(?:memex|jarvis|nabu)[.!,;\s]*){2,}$", re.IGNORECASE)
-
-_CLOSURE = re.compile(r"^\s*(?:vielen dank|danke(?:\s*(?:dir|sch(?:ö|oe)n|vielmals))?|merci(?:\s*vielmal)?|"
-                      r"thank(?:s| you)|ok(?:ay)?|gut|super|perfekt|alles klar|tsch(?:ü|ue)ss|"
-                      r"bis sp(?:ä|ae)ter|gute nacht)[.!,\s]*$", re.IGNORECASE)
-
-_SWITCH = re.compile(
-    r"^\s*(?:switch to|connect to|go to|wechsle zu|wechsel zu|verbinde mit|verbinde dich mit|"
-    r"gang uf|verbind mit|geh zu)\s+(?P<target>[\wäöüéè .-]+?)[.!?]?\s*$",
-    re.IGNORECASE,
-)
-
-
-def parse_switch_command(transcript: str) -> str | None:
-    """The raw target phrase of a spoken switch command, or None."""
-    match = _SWITCH.match(transcript.strip())
-    return match.group("target").strip() if match else None
-
-
-# The spoken CONTEXT commands — the side-panel model, by voice: one current thread is the
-# context; switch to another by topic, post into one by topic, or start fresh.
-_NEW_TOPIC = re.compile(
-    r"^\s*(?:neues thema|themawechsel|thema wechseln|new topic|"
-    r"(?:schliesse?|beende)\s+(?:das|den|dieses)?\s*(?:thema|thread|kontext)|"
-    r"close (?:the )?(?:topic|thread|context))[.!]?\s*$", re.IGNORECASE)
-_LIST_THREADS = re.compile(
-    r"^\s*(?:welche threads?\s+(?:sind|haben wir)\s+offen|liste\s+(?:der|die)\s+threads?|"
-    r"what threads?\s+(?:are|do we have)\s+open|list\s+(?:the\s+)?(?:open\s+)?threads?)"
-    r"\s*\??[.!]?\s*$", re.IGNORECASE)
-_SWITCH_THREAD = re.compile(
-    r"^\s*(?:wechsle|wechsel|geh|gehe|switch|go)\s+(?:zum|zu dem|to the|to)\s+thread\s*"
-    r"(?:über|ueber|about|on|zu)?\s+(?P<topic>[\wäöüéè .-]{2,50}?)[.!?]?\s*$", re.IGNORECASE)
-_POST_TO = re.compile(
-    r"^\s*(?:im|in dem|in den|an den|in the|to the|post to the|poste an den)\s+thread\s*"
-    r"(?:über|ueber|about|on|zu)?\s+(?P<topic>[^:,]{2,50}?)\s*[:,]\s+(?P<message>.{4,})$",
-    re.IGNORECASE)
-
-_DELEGATE = re.compile(
-    r"^\s*(?:frag|frage|ask)\s+(?:den|die|das|the)?\s*(?P<agent>[a-zA-Zäöü]+)[:,]?\s+"
-    r"(?:nach\s+|about\s+|to\s+)?(?P<task>.{4,})$",
-    re.IGNORECASE,
-)
-_DELEGATE_THREAD = re.compile(
-    r"^\s*(?:starte\s+(?:einen\s+)?thread|start\s+a\s+thread)[:,]?\s+(?P<task>.{4,})$",
-    re.IGNORECASE,
-)
-
-# Spoken agent names → the standard agents on the mesh. The gate keeps ordinary sentences
-# that happen to start with "ask …" from being swallowed as delegations.
-KNOWN_AGENTS = {"assistant": "Assistant", "researcher": "Researcher", "worker": "Worker",
-                "tutor": "Tutor", "voice": "Voice"}
-
-_DEFAULT_PHRASES = {
-    "error": "Sorry, that did not work.",
-    "hold": "Let me check. One moment please.",
-    "connected": "Connected to {name}.",
-    "unknown": "I don't know {target}. Available: {names}.",
-    "delegated": "Started a {agent} thread on {portal}. You can review it there.",
-    "no_mesh": "No mesh portal is configured for threads.",
-    "submitted": "Submitted to {portal}. I will tell you when the answer arrives.",
-    "new_topic": "Okay, new topic.",
-    "switched": "Now in the thread about {topic}.",
-    "posted": "Posted to the thread about {topic}. I will announce the answer.",
-    "no_thread": "I have no open thread about {topic}.",
-    "threads_open": "Open threads: {list}.",
-    "no_threads": "No open threads.",
-    "ready": "The answer about {topic} is ready. Say: read it.",
-    "nothing_new": "No new answers.",
-    "answer_to": "Answering your question: {question} —",
-    "radio_on": "Here comes {station}. Say stop to end it.",
-    "song_hint": "I cannot play single songs yet — but here comes {station}.",
-    "no_stations": "No radio stations are set up yet — add them under Voice, Station in the portal.",
-    "playing_song": "Here comes {title} by {artist}.",
-}
-
-async def load_stations(client, namespace: str) -> dict[str, tuple[str, str]]:
-    """Read {user}/Voice/Station/* nodes from the mesh: node NAME is the spoken/display
-    name, the markdown BODY's first http(s) line is the stream URL. User data — the Voice
-    package installs editable defaults; nothing is hard-coded here."""
-    import json as _json
-    stations: dict[str, tuple[str, str]] = {}
-    try:
-        listing = _json.loads(await client.call(
-            "search", {"query": f"namespace:{namespace}/Voice/Station", "limit": 30}))
-        for row in listing.get("results", []):
-            node = _json.loads(await client.call("get", {"path": f"@{row['path']}"}))
-            content = node.get("content") or {}
-            body = content.get("body") or content.get("content") or ""
-            url = next((line.strip() for line in str(body).splitlines()
-                        if line.strip().startswith(("http://", "https://"))), None)
-            name = node.get("name") or row.get("name") or row["path"].rsplit("/", 1)[-1]
-            if url:
-                stations[name.lower()] = (name, url)
-    except Exception:
-        import logging
-        logging.getLogger(__name__).warning("could not load stations from the mesh", exc_info=True)
-    return stations
-
-_READ = re.compile(
-    r"^\s*(?:vorlesen|lies\s+(?:es|sie|mir|die antwort)?\s*vor|antwort(?:en)? vorlesen|"
-    r"read (?:it|the answer)|play (?:it|the answer))[.!]?\s*$", re.IGNORECASE)
-
-# EMAIL routes DETERMINISTICALLY to the ExecutiveAssistant — a small local model told
-# "delegate email" still answers "open your mail program" often enough that the rule
-# cannot live in its prompt alone (observed 2026-08-20).
-_EMAIL = re.compile(r"\b(?:e-?mails?|mails?|inbox|posteingang|mailbox)\b", re.IGNORECASE)
-
-# MUSIC is deterministic too — the model answered a child's eight requests for a song
-# with invented promises about music agents that do not exist (observed 2026-08-20).
-# Radio streams play NOW; a named song gets radio plus an honest sentence until a music
-# library (Apple Music via Music Assistant) is connected.
-_MUSIC = re.compile(
-    r"^(?=.*\b(?:ab)?spiel\w*\b|.*\bplay\b)(?=.*\b(?:lied\w*|musik|songs?|radio)\b)|"
-    r"^\s*(?:musik|radio)\s*(?:an|bitte)?[.!]?\s*$", re.IGNORECASE | re.DOTALL)
-_MUSIC_OFF = re.compile(r"\b(?:musik|radio)\s+(?:aus|stopp?|off)\b|"
-                        r"\b(?:stopp?|stop)\s+(?:die\s+)?(?:musik|radio)\b", re.IGNORECASE)
-# Stations are USER DATA, never code: {user}/Voice/Station/* nodes in the mesh (the Voice
-# package installs editable defaults; the portal edits them). The router only ever sees
-# the loaded dict — spoken key → (display name, stream url) — via set_stations().
-
-
-class BrainRouter:
-    def __init__(self, brains: dict[str, Brain], active: str,
-                 phrases: dict[str, str] | None = None,
-                 mesh_brains: set[str] | None = None,
-                 home: object = None,
-                 agent_homes: dict[str, str] | None = None) -> None:
-        if active not in brains:
-            raise ValueError(f"active brain {active!r} not among {list(brains)}")
-        self._brains = brains
-        self.active = active
-        self._phrases = {**_DEFAULT_PHRASES, **(phrases or {})}
-        self._mesh = mesh_brains if mesh_brains is not None else {
-            n for n, b in brains.items() if hasattr(b, "delegate")}
-        self._home = home     # HomeAssistant client, when configured
-        self.player: object = None   # async url -> None; the satellite's media player
-        self.music: object = None    # MusicAssistant client, when a token is configured
-        # Spoken key → (display name, stream url), loaded from {user}/Voice/Station nodes.
-        self.stations: dict[str, tuple[str, str]] = {}
-        # Agent name → the portal that HOSTS it (a portal entry's "agents" list): the
-        # ExecutiveAssistant may live on the local mesh while Researcher lives in the cloud.
-        self._agent_homes = agent_homes or {}
-        # The SPOKEN CONTEXT — side-panel semantics: `_context` is THE current thread
-        # (delegations post into it until switched or closed), `_threads` lists everything
-        # opened this session, `_pending` carries spoken posts awaiting their announcement,
-        # `on_change` persists the session cookie after every mutation.
-        self._context: dict | None = None
-        self._threads: list[dict] = []
-        self._pending: list = []
-        # The MAILBOX: answers that arrived after their conversation ended. In signal mode
-        # the speaker plays a short ready-chime and the full text waits here for "vorlesen".
-        self._inbox: list[dict] = []
-        self.on_change: Callable[[], None] | None = None
-
-    # ----- the spoken context (session state) -----
-
-    def session_state(self) -> dict:
-        return {"portal": self.active, "context": self._context, "threads": self._threads,
-                "inbox": self._inbox}
-
-    def restore(self, state: dict) -> None:
-        """Resume a persisted session: active portal, context, open threads, unread answers."""
-        if state.get("portal") in self._brains:
-            self.active = state["portal"]
-        context = state.get("context")
-        if context and context.get("portal") in self._mesh:
-            self._context = context
-        self._threads = [t for t in state.get("threads", [])
-                         if t.get("portal") in self._mesh]
-        self._inbox = list(state.get("inbox", []))
-
-    def deliver_answer(self, handle: str, task: str, reply: str) -> str:
-        """An async answer arrived: store the full text in the mailbox and return the short
-        READY signal to speak — 'vorlesen' plays it. The answer's thread stays the pinned
-        context, so follow-ups continue exactly where the work happened."""
-        topic = task if len(task) <= 50 else task[:47] + "…"
-        self._inbox.append({"handle": handle, "task": task, "reply": reply})
-        for entry in self._threads:
-            if f"{entry['portal']}::{entry['path']}" == handle:
-                self._context = entry
-                break
-        self._changed()
-        return self._phrases["ready"].format(topic=topic)
-
-    def _changed(self) -> None:
-        if self.on_change is not None:
-            self.on_change()
-
-    async def sync_system_prompt(self, default_text: str) -> str:
-        """THE STANDARD VOICE PROMPT LIVES IN THE MESH, PER USER: read
-        @{namespace}/Voice/Prompt from the delegation portal; when absent, DEPOSIT the
-        built-in standard there so the user can edit it in the portal. The mesh node wins
-        over the built-in; a local SYSTEM_PROMPT_FILE (checked by the caller) wins over
-        both. Failures degrade to the built-in — the voice must come up without a mesh."""
-        import json as _json
-        import logging
-        target = self._mesh_target()
-        if target is None:
-            return default_text
-        client = self._brains[target]
-        ns = getattr(client, "namespace", None)
-        if not ns:
-            return default_text
-        path = f"{ns}/Voice/Prompt"
-        try:
-            node = _json.loads(await client.call("get", {"path": f"@{path}"}))  # type: ignore[attr-defined]
-            body = ((node.get("content") or {}).get("body") or "").strip()
-            if body:
-                logging.getLogger(__name__).info("system prompt loaded from @%s", path)
-                return body
-        except Exception as e:
-            logging.getLogger(__name__).info("no prompt node at @%s (%r) — depositing", path, e)
-        # THE PLATFORM owns the standard: the Voice package's @Voice/Prompt node is the
-        # source the per-user copy is seeded from; the code constant is only the fallback
-        # for a mesh that has no Voice package at all.
-        try:
-            node = _json.loads(await client.call("get", {"path": "@Voice/Prompt"}))  # type: ignore[attr-defined]
-            body = ((node.get("content") or {}).get("body") or "").strip()
-            if body:
-                default_text = body
-                logging.getLogger(__name__).info("standard prompt taken from @Voice/Prompt")
-        except Exception:
-            pass
-        try:
-            await client.call("create", {"node": _json.dumps({  # type: ignore[attr-defined]
-                "id": "Prompt", "namespace": f"{ns}/Voice",
-                "name": "Voice System Prompt", "nodeType": "Markdown",
-                "content": {"$type": "MarkdownContent", "body": default_text}})})
-            logging.getLogger(__name__).info("system prompt DEPOSITED at @%s — edit it there", path)
-        except Exception as e:
-            logging.getLogger(__name__).warning("could not deposit the voice prompt at @%s: %r", path, e)
-        return default_text
-
-    def apply_system_prompt(self, text: str) -> None:
-        for brain in self._brains.values():
-            if hasattr(brain, "system_prompt"):
-                brain.system_prompt = text  # type: ignore[attr-defined]
-
-    def _remember(self, portal: str, path: str, task: str, agent: str | None) -> dict:
-        import time
-        entry = next((t for t in self._threads if t["path"] == path), None)
-        if entry is None:
-            entry = {"portal": portal, "path": path,
-                     "task": task if len(task) <= 80 else task[:77] + "…",
-                     "agent": agent or ""}
-            self._threads.append(entry)
-        entry["last"] = time.time()
-        self._context = entry
-        self._changed()
-        return entry
-
-    async def _play_named(self, request: str) -> str | None:
-        """Resolve a spoken song wish through Music Assistant and play it on the first MA
-        player. None = could not resolve/play → the caller falls back to radio + the
-        honest sentence, never to silence or an invented promise."""
-        import logging
-        try:
-            query = re.sub(r".*?\b(?:heißen|heissen|namens|called|titled)\b", "", request,
-                           flags=re.IGNORECASE).strip(" .!?,") or request
-            results = await self.music.search(query)  # type: ignore[attr-defined]
-            tracks = (results or {}).get("tracks") or []
-            if not tracks:
-                return None
-            track = tracks[0]
-            players = await self.music.players()  # type: ignore[attr-defined]
-            available = [p for p in players if p.get("available", True)]
-            if not available:
-                return None
-            await self.music.play(track["uri"], available[0]["player_id"])  # type: ignore[attr-defined]
-            artist = ((track.get("artists") or [{}])[0]).get("name", "")
-            title = track.get("name", "")
-            return self._phrases["playing_song"].format(title=title, artist=artist)
-        except Exception:
-            logging.getLogger(__name__).warning("music assistant play failed", exc_info=True)
-            return None
-
-    def _match_station(self, lowered: str) -> str | None:
-        """Best station for an utterance by token overlap — 'radio' itself never decides."""
-        heard = set(re.findall(r"[a-z0-9äöüéè]+", lowered)) - {"radio"}
-        best, best_score = None, 0
-        for station_key in self.stations:
-            tokens = set(re.findall(r"[a-z0-9äöüéè]+", station_key)) - {"radio"}
-            score = len(tokens & heard)
-            if score > best_score:
-                best, best_score = station_key, score
-        return best
-
-    def _find_thread(self, topic: str) -> dict | None:
-        """Fuzzy topic → open thread: substring or word overlap on task/agent, most
-        recently used first."""
-        wanted = topic.lower().strip()
-        words = {w for w in re.split(r"\W+", wanted) if len(w) > 2}
-        best = None
-        for entry in sorted(self._threads, key=lambda t: t.get("last", 0), reverse=True):
-            haystack = f"{entry['task']} {entry['agent']}".lower()
-            if wanted in haystack or (words and words <= set(re.split(r"\W+", haystack))):
-                return entry
-            if best is None and words and words & set(re.split(r"\W+", haystack)):
-                best = entry
-        return best
-
-    def _mesh_target(self) -> str | None:
-        """The portal delegations go to: the active brain when it is a mesh, else the FIRST
-        mesh in configured order — `_mesh` is a set, and iterating it directly once sent
-        delegations to an arbitrary portal (observed: the prompt sync landing on systemorph
-        instead of the local mesh)."""
-        if self.active in self._mesh:
-            return self.active
-        return next((name for name in self._brains if name in self._mesh), None)
-
-    async def delegate_task(self, task: str, agent: str | None = None) -> str:
-        """The local brain's triage seam, with CONTEXT: while a context thread is open,
-        follow-ups post INTO it (the mesh agent keeps the whole conversation); a different
-        explicit agent reuses/opens that agent's own thread and the context switches to it —
-        the side-panel model. Returns the STAMPED handle so await_reply later polls the
-        right brain. Raises when no mesh is configured."""
-        context = self._context
-        if context is not None and agent and agent != (context.get("agent") or None):
-            context = next((t for t in self._threads if t["agent"] == agent), None)
-        if context is not None:
-            portal, path = context["portal"], context["path"]
-            await self._brains[portal].submit(path, task, agent or context["agent"] or None)  # type: ignore[attr-defined]
-            self._remember(portal, path, context["task"], context["agent"] or None)
-            return f"{portal}::{path}"
-        target = None
-        if agent and (housed := self._agent_homes.get(agent)) in self._mesh:
-            target = housed
-        target = target or self._mesh_target()
-        if target is None:
-            raise RuntimeError("no mesh portal configured")
-        path = await self._brains[target].delegate(task, agent)  # type: ignore[attr-defined]
-        self._remember(target, path, task, agent)
-        import logging
-        logging.getLogger(__name__).info("delegated to %s (%s): %r", target, agent or "-", task[:80])
-        return f"{target}::{path}"
-
-    # Irreversible mesh tools stay behind an explicit opt-in — one mis-heard word must
-    # never delete a node. Everything else on the portal's MCP surface passes through.
-    _DESTRUCTIVE = {"delete", "restore_version", "restore_from_point_in_time"}
-    allow_destructive: bool = False
-
-    async def refresh_stations(self) -> None:
-        """Load the user's stations from the mesh (the delegation portal's namespace)."""
-        target = self._mesh_target()
-        client = self._brains.get(target) if target else None
-        ns = getattr(client, "namespace", None)
-        if client is not None and ns:
-            self.stations = await load_stations(client, ns)
-
-    async def run_tool(self, name: str, args: dict) -> str:
-        """The local brain's quick tools, run in-round: mesh calls go to the same portal
-        delegations would (the active brain when it is a mesh, else the first mesh);
-        home_assistant goes to the configured HA instance. mesh_tool is the FULL MCP
-        passthrough — any tool on the portal, by name."""
-        if name == "home_assistant":
-            if self._home is None:
-                return "Home Assistant is not configured."
-            return await self._home.run(args)
-        target = self._mesh_target()
-        if target is None:
-            return "No mesh portal is configured."
-        client = self._brains[target]
-        if name == "search_mesh":
-            return await client.call("search", {"query": str(args.get("query", "")).strip(),
-                                                "limit": 8})  # type: ignore[attr-defined]
-        if name == "get_node":
-            return await client.call("get", {"path": str(args.get("path", "")).strip()})  # type: ignore[attr-defined]
-        if name == "mesh_tool":
-            import json as _json
-            tool = str(args.get("tool", "")).strip()
-            if tool in self._DESTRUCTIVE and not self.allow_destructive:
-                return f"The tool {tool} is destructive and disabled for voice."
-            raw = args.get("arguments") or {}
-            if isinstance(raw, str):
-                try: raw = _json.loads(raw)
-                except Exception: return "arguments must be a JSON object."
-            return await client.call(tool, raw)  # type: ignore[attr-defined]
-        return f"Unknown tool: {name}"
-
-    def drain_delegations(self) -> list:
-        """Pending (handle, task) pairs from ANY brain that collects them (the local one),
-        plus spoken posts routed by handle_command."""
-        pending, self._pending = self._pending, []
-        for brain in self._brains.values():
-            drain = getattr(brain, "drain_delegations", None)
-            if drain:
-                pending.extend(drain())
-        return pending
-
-    def describe_hold(self, handle: str) -> str:
-        """What to say when the answer will come later — mesh submissions are ACKNOWLEDGED
-        by portal name, because their answers can arrive highly asynchronously."""
-        name, _, _ = handle.partition("::")
-        if name in self._mesh:
-            return self._phrases["submitted"].format(portal=name)
-        return self._phrases["hold"]
-
-    def resolve(self, spoken: str) -> str | None:
-        """Match a spoken target against the configured names, forgivingly."""
-        wanted = spoken.lower().strip()
-        for name in self._brains:
-            lowered = name.lower()
-            if wanted == lowered or wanted.startswith(lowered) or lowered.startswith(wanted):
-                return name
-        return None
-
-    async def handle_command(self, transcript: str) -> str | None:
-        """Returns the spoken confirmation when the transcript was a command;
-        empty string = handled silently (say nothing)."""
-        if (_STOP.match(transcript.strip()) or _CLOSURE.match(transcript.strip())
-                or _CHANT.match(transcript.strip())):
-            return ""     # stop or courteous closure: end quietly, never reply to a reply
-
-        # The spoken CONTEXT commands come BEFORE the portal switch — "wechsle zum Thread
-        # über X" must never be eaten by "wechsle zu {portal}".
-        stripped = transcript.strip()
-        if _READ.match(stripped):
-            if not self._inbox:
-                return self._phrases["nothing_new"]
-            item = self._inbox.pop(0)
-            self._changed()
-            question = item["task"] if len(item["task"]) <= 60 else item["task"][:57] + "…"
-            return f"{self._phrases['answer_to'].format(question=question)} {item['reply']}"
-        if _NEW_TOPIC.match(stripped):
-            self._context = None
-            self._changed()
-            return self._phrases["new_topic"]
-        if _LIST_THREADS.match(stripped):
-            if not self._threads:
-                return self._phrases["no_threads"]
-            names = ", ".join(t["task"] if len(t["task"]) <= 40 else t["task"][:37] + "…"
-                              for t in self._threads[-6:])
-            return self._phrases["threads_open"].format(list=names)
-        posted = _POST_TO.match(stripped)
-        if posted is not None:
-            entry = self._find_thread(posted.group("topic"))
-            if entry is None:
-                return self._phrases["no_thread"].format(topic=posted.group("topic").strip())
-            message = posted.group("message").strip()
-            await self._brains[entry["portal"]].submit(entry["path"], message,
-                                                       entry["agent"] or None)  # type: ignore[attr-defined]
-            self._remember(entry["portal"], entry["path"], entry["task"], entry["agent"] or None)
-            self._pending.append((f"{entry['portal']}::{entry['path']}", message))
-            return self._phrases["posted"].format(topic=posted.group("topic").strip())
-        if _MUSIC_OFF.search(stripped) and self.player is not None:
-            return ""    # the interrupt path stops the player quietly
-        lowered = stripped.lower()
-        # Radio matching survives what STT does to the words: the device loses the first
-        # ~half second after the wake word AND mangles station names ("Spiel Radio SRF 3"
-        # arrived as "Die Radio-SRF 3." then "Spielradio SR-Fans." — observed). Stations
-        # are USER-NAMED nodes, so matching scores token overlap ("Energy" finds "Energy
-        # Zürich", the digit separates SRF 3 from SRF 1); any mention of radio — substring,
-        # because "Spielradio" fuses — plays the first configured one; no verb required.
-        key = self._match_station(lowered)
-        if (key or "radio" in lowered or _MUSIC.search(stripped)) \
-                and self.player is not None:
-            named_song = key is None and re.search(
-                r"\b(?:lied|song)\b", lowered) and len(stripped) > 25
-            # A NAMED song goes to Music Assistant when it is connected — THEIR tooling
-            # (Spotify / Apple Music providers) resolves and streams it.
-            if named_song and self.music is not None:
-                spoken = await self._play_named(stripped)
-                if spoken is not None:
-                    return spoken
-            if not self.stations:
-                return self._phrases["no_stations"]
-            name, url = self.stations[key or next(iter(self.stations))]
-            try:
-                await self.player(url)  # type: ignore[operator]
-            except Exception:
-                return self._phrases["error"]
-            if named_song:
-                return self._phrases["song_hint"].format(station=name)
-            return self._phrases["radio_on"].format(station=name)
-        if _EMAIL.search(stripped) and self._mesh_target() is not None:
-            handle = await self.delegate_task(stripped, "ExecutiveAssistant")
-            self._pending.append((handle, stripped))
-            return self._phrases["submitted"].format(portal=handle.partition("::")[0])
-        switched = _SWITCH_THREAD.match(stripped)
-        if switched is not None:
-            entry = self._find_thread(switched.group("topic"))
-            if entry is None:
-                return self._phrases["no_thread"].format(topic=switched.group("topic").strip())
-            self._context = entry
-            self._changed()
-            return self._phrases["switched"].format(topic=switched.group("topic").strip())
-
-        # Delegation: launch a real thread for a STANDARD agent on the mesh and leave the
-        # work to be evaluated THERE — the speaker only confirms the submission.
-        delegated = _DELEGATE_THREAD.match(transcript.strip())
-        agent_name: str | None = None
-        if delegated is None:
-            match = _DELEGATE.match(transcript.strip())
-            if match and match.group("agent").lower() in KNOWN_AGENTS:
-                delegated = match
-                agent_name = KNOWN_AGENTS[match.group("agent").lower()]
-        if delegated is not None:
-            if self._mesh_target() is None:
-                return self._phrases["no_mesh"]
-            if _DELEGATE_THREAD.match(transcript.strip()):
-                self._context = None   # "start a thread" is EXPLICITLY a fresh one
-            handle = await self.delegate_task(delegated.group("task").strip(), agent_name)
-            return self._phrases["delegated"].format(agent=agent_name or "Assistant",
-                                                     portal=handle.partition("::")[0])
-
-        spoken = parse_switch_command(transcript)
-        if spoken is None:
-            return None
-        name = self.resolve(spoken)
-        if name is None:
-            return self._phrases["unknown"].format(target=spoken,
-                                                   names=", ".join(self._brains))
-        self.active = name
-        self._changed()   # the active portal is part of the persisted session
-        return self._phrases["connected"].format(name=name)
-
-    async def ask(self, text: str) -> str:
-        return f"{self.active}::{await self._brains[self.active].ask(text)}"
-
-    async def await_reply(self, handle: str, budget_s: float) -> str | None:
-        # The handle is stamped with its brain so a late announce still polls the brain
-        # that produced it, even if the active brain changed meanwhile.
-        name, _, inner = handle.partition("::")
-        return await self._brains[name].await_reply(inner, budget_s)
-
-    def stream_text(self, handle: str):
-        """The producing brain's live text stream for this handle, or None (brain doesn't stream)."""
-        name, _, inner = handle.partition("::")
-        stream = getattr(self._brains[name], "stream_text", None)
-        return stream(inner) if stream else None
-
-    async def close(self) -> None:
-        for brain in self._brains.values():
-            await brain.close()
-        if self._home is not None:
-            await self._home.close()  # type: ignore[attr-defined]
-        if self.music is not None:
-            await self.music.close()  # type: ignore[attr-defined]
diff --git a/clients/voice-gateway/memex_voice_gateway/satellite.py b/clients/voice-gateway/memex_voice_gateway/satellite.py
deleted file mode 100644
index 0b2ded916a..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/satellite.py
+++ /dev/null
@@ -1,292 +0,0 @@
-"""The LAN link to the ESPHome voice satellite (e.g. FutureProofHomes Satellite1).
-
-Speaks the same aioesphomeapi surface Home Assistant uses: `subscribe_voice_assistant`
-(API-audio mode — the handler returns port 0), `send_voice_assistant_event` for the
-RUN/STT/TTS event sequence that drives the device's LEDs and player, and
-`send_voice_assistant_announcement_await_response` (with a media-player fallback) for
-answers that outlive the voice run.
-
-The device is the SERVER — this gateway dials it on the LAN, so it can run beside a Home
-Assistant that owns the satellite's sensors and media, as long as only ONE of them
-subscribes as the voice assistant (leave the device unassigned in HA's Assist).
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Awaitable, Callable
-
-from aioesphomeapi import APIClient
-from aioesphomeapi.model import VoiceAssistantAudioSettings, VoiceAssistantEventType as Event
-
-from .config import Config
-from .pipeline import VoicePipeline
-from .vad import Endpointer
-
-logger = logging.getLogger(__name__)
-
-
-class SatelliteLink:
-    def __init__(self, cfg: Config, pipeline: VoicePipeline) -> None:
-        self.cfg = cfg
-        self.pipeline = pipeline
-        self.client = APIClient(
-            cfg.satellite_host, cfg.satellite_port,
-            cfg.satellite_password, noise_psk=cfg.satellite_psk,
-        )
-        self._endpointer: Endpointer | None = None
-        self._alt_audio = bytearray()   # channel 1 of the round, for capture diagnostics
-        self._utterance_done = asyncio.Event()
-        self._media_player_key: int | None = None
-        self._round_task: asyncio.Task | None = None
-        self._follow_up = False
-        self._round_serial = 0
-        self._noise_strikes: list[float] = []
-        self._suppress_until = 0.0
-        self.on_wake: Callable[[], Awaitable[None]] | None = None  # barge-in hook
-
-    async def stop_playback(self) -> None:
-        """Stop whatever the media player is doing — the device half of a barge-in."""
-        if self._media_player_key is None:
-            return
-        try:
-            from aioesphomeapi.model import MediaPlayerCommand
-            self.client.media_player_command(self._media_player_key,
-                                             command=MediaPlayerCommand.STOP)
-        except Exception:
-            logger.debug("media stop failed", exc_info=True)
-
-    async def play_media(self, url: str) -> None:
-        """Start a media stream (radio, music) on the device's player."""
-        if self._media_player_key is None:
-            raise RuntimeError("no media player entity on the device")
-        self.client.media_player_command(self._media_player_key, media_url=url)
-
-    # --- lifecycle -------------------------------------------------------------------
-
-    async def run_forever(self) -> None:
-        backoff = 2.0
-        while True:
-            try:
-                await self.client.connect(login=True)
-                info = await self.client.device_info()
-                logger.info("connected to %s (%s)", info.name, self.cfg.satellite_host)
-                await self._find_media_player()
-                unsubscribe = self.client.subscribe_voice_assistant(
-                    handle_start=self._handle_start,
-                    handle_stop=self._handle_stop,
-                    handle_audio=self._handle_audio,
-                )
-                await self._ensure_wake_word()
-                backoff = 2.0
-                try:
-                    while self.client._connection is not None:  # noqa: SLF001 — liveness probe
-                        await asyncio.sleep(5)
-                finally:
-                    unsubscribe()
-            except Exception as error:
-                logger.warning("satellite link lost (%s); retrying in %.0fs", error, backoff)
-            await asyncio.sleep(backoff)
-            backoff = min(backoff * 2, 60)
-
-    async def _find_media_player(self) -> None:
-        entities, _ = await self.client.list_entities_services()
-        for entity in entities:
-            if type(entity).__name__ == "MediaPlayerInfo":
-                self._media_player_key = entity.key
-                return
-
-    async def _ensure_wake_word(self) -> None:
-        """Activate a wake word if none is active.
-
-        Modern ESPHome voice firmware hands wake-word selection to the API client (HA
-        normally does this), so a factory-fresh device can sit with NO active wake word —
-        it hears nothing and no voice run ever starts. The configuration request is only
-        answered on the connection that holds the voice-assistant subscription, so this
-        must run here, not from a side channel.
-        """
-        try:
-            conf = await self.client.get_voice_assistant_configuration(timeout=10)
-        except Exception:
-            logger.info("device does not answer wake-word configuration (older firmware) — skipping")
-            return
-        available = [w.id for w in conf.available_wake_words]
-        active = list(conf.active_wake_words)
-        logger.info("wake words available=%s active=%s", available, active)
-        if not available:
-            return
-        wanted = self.cfg.wake_word
-        chosen = wanted if wanted in available else (active[0] if active else available[0])
-        if wanted and wanted not in available:
-            logger.warning("WAKE_WORD %r not on the device; using %r", wanted, chosen)
-        # The CONFIGURED wake word must actually be active — a reflash or NVS can leave an
-        # old selection in place, and "available but inactive" hears nothing.
-        limit = getattr(conf, "max_active_wake_words", 1) or 1
-        # Prefer the configured word; keep a proven fallback model active beside it when the
-        # device allows more than one (a young custom model should not be the only ear).
-        fallback = [w for w in ("hey_jarvis", *active) if w in available and w != chosen]
-        desired = ([chosen] + fallback)[:limit]
-        if set(desired) != set(active):
-            await self.client.set_voice_assistant_configuration(active_wake_words=desired)
-            logger.info("activated wake words %s (max %s)", desired, limit)
-
-    # --- voice assistant callbacks ----------------------------------------------------
-
-    async def _handle_start(
-        self, conversation_id: str, flags: int,
-        audio_settings: VoiceAssistantAudioSettings, wake_word_phrase: str | None,
-    ) -> int:
-        # WAKE-STORM SUPPRESSION: repeated junk rounds mean the wake word is being triggered
-        # by ambient audio (a TV) or our own playback — go deaf for a cooldown instead of
-        # answering the room. Silence from the user must mean silence from the device.
-        import time as _time
-        if _time.monotonic() < self._suppress_until:
-            logger.info("wake ignored (suppressed for %.0fs after a wake storm)",
-                        self._suppress_until - _time.monotonic())
-            return 0
-        # NOTE: playback is deliberately NOT interrupted here — a false wake must not kill a
-        # real answer. The interrupt happens once the round yields actual speech (or "stop").
-        # No wake-word phrase = a CONTINUED conversation (start_conversation re-opened the
-        # mic). Those rounds calibrate against ambient audio (a TV must not become the
-        # conversation partner) and give up early when nobody starts speaking.
-        follow_up = not wake_word_phrase
-        logger.info("wake (%s)", wake_word_phrase or "follow-up")
-        self._follow_up = follow_up
-        self._round_serial += 1
-        self._endpointer = Endpointer(
-            sample_rate=self.cfg.sample_rate,
-            silence_ms=self.cfg.silence_ms,
-            max_utterance_s=self.cfg.max_utterance_s,
-            min_utterance_s=self.cfg.min_utterance_s,
-            # EVERY round ignores its first moments: a wake round starts with the wake
-            # word's own tail (which must not count as the utterance — it made rounds close
-            # ~1s after wake, before the question was asked), a follow-up starts with room
-            # ambience. The lead-in calibrates the noise floor instead of listening.
-            calibrate_ms=400 if follow_up else 600,
-            onset_timeout_s=5.0 if follow_up else 8.0,
-        )
-        self._utterance_done.clear()
-        self._alt_audio = bytearray()
-        self._round_task = asyncio.create_task(self._run_round())
-        return 0  # 0 = stream microphone audio over the API connection (no UDP)
-
-    async def _handle_audio(self, data: bytes, data2: bytes | None = None) -> None:
-        # Two channels on devices with MULTI_CHANNEL_AUDIO (the XMOS sends two feeds);
-        # we feed channel 0 to STT and RECORD channel 1 beside it — which one is actually
-        # the echo-cancelled/beamformed feed is an ASSUMPTION under test (2026-08-20:
-        # every STT model garbles room audio while the on-device wake engine hears fine).
-        endpointer = self._endpointer
-        if data2 and self._endpointer is not None:
-            self._alt_audio.extend(data2)
-        if endpointer is not None and endpointer.feed(data):
-            self._utterance_done.set()
-
-    async def _handle_stop(self, *_args) -> None:
-        self._utterance_done.set()
-
-    # --- the round ---------------------------------------------------------------------
-
-    async def _run_round(self) -> None:
-        serial = self._round_serial
-        send = self.client.send_voice_assistant_event
-        send(Event.VOICE_ASSISTANT_RUN_START, {})
-        send(Event.VOICE_ASSISTANT_STT_START, {})
-        try:
-            await asyncio.wait_for(self._utterance_done.wait(),
-                                   timeout=self.cfg.max_utterance_s + 5)
-        except asyncio.TimeoutError:
-            pass
-        endpointer, self._endpointer = self._endpointer, None
-        pcm = endpointer.audio if endpointer else b""
-        # Retain the raw utterance locally when configured: real-voice recordings are the
-        # retraining corpus that fixes what synthetic TTS samples cannot (the owner's accent).
-        if self.cfg.record_dir and pcm:
-            try:
-                import os as _os
-                import time as _t
-                from .stt import wav_from_pcm as _wav
-                _os.makedirs(self.cfg.record_dir, exist_ok=True)
-                name = f"round_{_t.strftime('%Y%m%d_%H%M%S')}_{'fu' if self._follow_up else 'wake'}.wav"
-                with open(_os.path.join(self.cfg.record_dir, name), "wb") as f:
-                    f.write(_wav(pcm, self.cfg.sample_rate))
-                if self._alt_audio:   # channel 1, for the which-channel-is-clean experiment
-                    with open(_os.path.join(self.cfg.record_dir,
-                                            name.replace(".wav", "_ch2.wav")), "wb") as f:
-                        f.write(_wav(bytes(self._alt_audio), self.cfg.sample_rate))
-            except Exception:
-                logger.debug("recording save failed", exc_info=True)
-        # A follow-up that never paused (TV, music) or never started (silence) is not
-        # addressed to the assistant: end the conversation quietly instead of answering it.
-        if self._follow_up and endpointer is not None and endpointer.ended_by_cap:
-            logger.info("follow-up discarded (%s) — conversation ends",
-                        "continuous audio" if endpointer.speech_seen else "silence")
-            send(Event.VOICE_ASSISTANT_RUN_END, {})
-            return
-
-        try:
-            result = await self.pipeline.run(pcm)
-            if result.transcript:
-                send(Event.VOICE_ASSISTANT_STT_END, {"text": result.transcript})
-        except Exception as error:
-            logger.exception("voice round failed")
-            send(Event.VOICE_ASSISTANT_ERROR, {"code": "gateway", "message": str(error)[:200]})
-            send(Event.VOICE_ASSISTANT_RUN_END, {})
-            return
-        # Junk-round accounting: three noise rounds inside a minute = a wake storm; go deaf
-        # for 60s rather than machine-gunning answers at a TV.
-        import time as _time
-        if result.noise:
-            now = _time.monotonic()
-            self._noise_strikes = [t for t in self._noise_strikes if now - t < 60] + [now]
-            if len(self._noise_strikes) >= 3:
-                self._suppress_until = now + 60
-                self._noise_strikes.clear()
-                logger.warning("wake storm detected — suppressing wakes for 60s")
-        elif result.transcript:
-            self._noise_strikes.clear()
-            # REAL speech arrived: NOW interrupt whatever was still playing (barge-in), and
-            # on an explicit "stop" also silence the media player.
-            if self.on_wake is not None:
-                try:
-                    await self.on_wake()
-                except Exception:
-                    logger.debug("barge-in interrupt failed", exc_info=True)
-            if result.interrupt:
-                await self.stop_playback()
-        # End the run FIRST, then deliver the reply as an ANNOUNCEMENT with
-        # start_conversation: the device plays it and — when playback finishes — opens the
-        # mic again by itself, no wake word ("conversation mode"). A silent follow-up ends
-        # the chain via the pipeline's quiet empty-transcript path.
-        send(Event.VOICE_ASSISTANT_RUN_END, {})
-        # SUPERSEDED replies are dropped, not queued: if another wake started meanwhile,
-        # playing this answer late would drain a stale backlog at the listener (observed
-        # with a TV feeding rounds faster than they played).
-        if result.tts_url and serial == self._round_serial:
-            await self.announce(result.tts_url, result.reply or "",
-                                start_conversation=self.cfg.continue_conversation
-                                and bool(result.transcript))
-        elif result.tts_url:
-            logger.info("reply superseded by a newer round — not played")
-
-    # --- late answers --------------------------------------------------------------------
-
-    async def announce(self, url: str, text: str, start_conversation: bool = False) -> None:
-        """Deliver a reply. Prefers the voice-assistant announcement (waits for playback;
-        `start_conversation` re-opens the mic when it ends), falls back to a media-player
-        announcement command."""
-        announce_api = getattr(self.client, "send_voice_assistant_announcement_await_response", None)
-        if announce_api is not None:
-            try:
-                try:
-                    await announce_api(url, 120.0, text, start_conversation=start_conversation)
-                except TypeError:
-                    await announce_api(url, 120.0, text)   # older aioesphomeapi: no kwarg
-                return
-            except Exception:
-                logger.debug("announcement API failed; falling back to media player", exc_info=True)
-        if self._media_player_key is not None:
-            self.client.media_player_command(
-                self._media_player_key, media_url=url, announcement=True)
-        else:
-            logger.error("no announcement path available — reply dropped: %s", text[:100])
diff --git a/clients/voice-gateway/memex_voice_gateway/session.py b/clients/voice-gateway/memex_voice_gateway/session.py
deleted file mode 100644
index 7b5afa55e8..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/session.py
+++ /dev/null
@@ -1,48 +0,0 @@
-"""The speaker's SESSION COOKIE — spoken context, persisted with an expiry.
-
-The voice conversation has the same context model as the portal's side panel: one CURRENT
-thread is the context, everything posts into it until the user switches ("wechsle zum
-Thread über …") or starts fresh ("neues Thema"). That state — active portal, current
-context, the open threads — is persisted to disk per speaker and expires after a TTL,
-exactly like an MCP session id: a gateway restart inside the window resumes where the
-conversation was; after the window, the speaker starts clean.
-"""
-
-from __future__ import annotations
-
-import json
-import time
-from pathlib import Path
-
-
-class SpokenSession:
-    def __init__(self, path: str, ttl_hours: float = 8.0) -> None:
-        self._path = Path(path).expanduser()
-        self._ttl_s = ttl_hours * 3600
-
-    def load(self) -> dict:
-        """The persisted session, or {} when absent/expired/corrupt."""
-        try:
-            state = json.loads(self._path.read_text())
-        except (OSError, ValueError):
-            return {}
-        if float(state.get("expires_at", 0)) < time.time():
-            return {}
-        return state
-
-    def save(self, **state) -> None:
-        """Persist and re-arm the expiry — every interaction extends the session. Accepts
-        whatever the router's session_state carries (portal, context, threads, inbox, …);
-        a keyword-frozen signature once crashed every state change when the state grew."""
-        state["expires_at"] = time.time() + self._ttl_s
-        try:
-            self._path.parent.mkdir(parents=True, exist_ok=True)
-            self._path.write_text(json.dumps(state, indent=2))
-        except OSError:
-            pass   # a failed persist degrades to an in-memory session, never breaks a round
-
-    def clear(self) -> None:
-        try:
-            self._path.unlink(missing_ok=True)
-        except OSError:
-            pass
diff --git a/clients/voice-gateway/memex_voice_gateway/stt.py b/clients/voice-gateway/memex_voice_gateway/stt.py
deleted file mode 100644
index 7ad167a38f..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/stt.py
+++ /dev/null
@@ -1,64 +0,0 @@
-"""Speech-to-text over HTTP — one client for both hosting modes.
-
-The mesh's `POST /api/speech/transcribe` (Bearer auth, in front of the cluster-internal
-whisper.cpp — Doc/Architecture/CentralizedSpeech) and a LOCAL whisper.cpp server's
-`POST /inference` speak the same multipart contract: `file` + `language`
-(+ `response_format=json`, which the mesh accepts and ignores) → `{"text": …}`.
-So the gateway just points STT_URL at whichever one it uses.
-"""
-
-from __future__ import annotations
-
-import struct
-
-import aiohttp
-
-
-def wav_from_pcm(pcm: bytes, sample_rate: int = 16000, channels: int = 1) -> bytes:
-    """Minimal RIFF/WAVE wrapper for 16-bit PCM."""
-    byte_rate = sample_rate * channels * 2
-    block_align = channels * 2
-    header = b"RIFF" + struct.pack("<I", 36 + len(pcm)) + b"WAVE"
-    header += b"fmt " + struct.pack("<IHHIIHH", 16, 1, channels, sample_rate, byte_rate, block_align, 16)
-    header += b"data" + struct.pack("<I", len(pcm))
-    return header + pcm
-
-
-def resample_to_16k(pcm: bytes, rate: int) -> bytes:
-    """Integer-factor downsample to 16 kHz (pairwise mean then decimate) — whisper.cpp's
-    server assumes 16 kHz and reads anything else at the wrong speed (chipmunk noise that
-    transcribes as *Klopfen*/*Musik* hallucinations; bitten live with the 32 kHz firmware)."""
-    if rate == 16000 or rate % 16000:
-        return pcm
-    factor = rate // 16000
-    import array
-    samples = array.array("h")
-    samples.frombytes(pcm[: len(pcm) - (len(pcm) % (2 * factor))])
-    out = array.array("h", (sum(samples[i:i + factor]) // factor
-                            for i in range(0, len(samples) - factor + 1, factor)))
-    return out.tobytes()
-
-
-async def transcribe(
-    session: aiohttp.ClientSession,
-    url: str,
-    token: str | None,
-    pcm: bytes,
-    *,
-    language: str = "de",
-    sample_rate: int = 16000,
-) -> str:
-    """Returns the transcript text; raises on transport errors, empty text on silence."""
-    pcm = resample_to_16k(pcm, sample_rate)
-    sample_rate = 16000
-    form = aiohttp.FormData()
-    form.add_field("file", wav_from_pcm(pcm, sample_rate), filename="utterance.wav",
-                   content_type="audio/wav")
-    form.add_field("language", language)
-    form.add_field("response_format", "json")
-    headers = {"Authorization": f"Bearer {token}"} if token else {}
-    async with session.post(url, data=form, headers=headers,
-                            timeout=aiohttp.ClientTimeout(total=60)) as response:
-        response.raise_for_status()
-        payload = await response.json(content_type=None)
-        return (payload.get("text") or "").strip()
diff --git a/clients/voice-gateway/memex_voice_gateway/threads.py b/clients/voice-gateway/memex_voice_gateway/threads.py
deleted file mode 100644
index bc4e6e2cf3..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/threads.py
+++ /dev/null
@@ -1,203 +0,0 @@
-"""The memex thread surface, spoken over MCP streamable HTTP.
-
-The mesh's `/mcp` endpoint takes plain JSON-RPC POSTs with a Bearer token: `initialize`
-(capture `Mcp-Session-Id`), `notifications/initialized`, then `tools/call`. Responses arrive
-as JSON or as a single-event SSE body — both are handled. This mirrors the framing already
-proven by education/scripts/upload-videos.py.
-
-Thread lifecycle (verified against live nodes, 2026-08-18):
-  start_thread → {"status":"Started","threadPath":…}; the agent runs asynchronously.
-  The thread node's content lists message ids in `messages`; children only materialize at
-  round end as ThreadMessage nodes ({"role":"assistant","text":…,"status":"Completed"}).
-  A failed dispatch leaves no assistant child but writes the failure into `summary`.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import time
-from dataclasses import dataclass, field
-
-import aiohttp
-
-
-class McpError(RuntimeError):
-    pass
-
-
-def parse_tool_result(body: str) -> str:
-    """Extract the tool's text payload from a JSON or single-event SSE response body."""
-    for line in body.splitlines():
-        if line.startswith("data:"):
-            body = line[5:].strip()
-            break
-    result = json.loads(body)
-    if "error" in result:
-        raise McpError(json.dumps(result["error"]))
-    parts = result.get("result", {}).get("content", [])
-    if result.get("result", {}).get("isError"):
-        raise McpError(parts[0].get("text", "tool error") if parts else "tool error")
-    return parts[0].get("text", "") if parts else json.dumps(result)
-
-
-def extract_reply(thread_json: str, known_ids: set[str]) -> tuple[list[str], str | None]:
-    """From a thread node's JSON: (new message ids, dispatch-failure summary or None).
-
-    The summary is only a failure signal while no assistant reply exists AND nothing is
-    pending — a completed round always carries its reply as a message child.
-    """
-    node = json.loads(thread_json)
-    content = node.get("content") or {}
-    ids = [m for m in content.get("messages", []) if m not in known_ids]
-    pending = content.get("pendingUserMessages") or {}
-    summary = content.get("summary")
-    failure = summary if (not ids and not pending and summary) else None
-    return ids, failure
-
-
-@dataclass
-class MemexThreads:
-    base_url: str
-    token: str
-    namespace: str
-    agent: str | None = None
-    thread_idle_minutes: float = 5.0
-    verify_tls: bool = True   # False for a local mesh with a self-signed certificate
-
-    _session_id: str | None = field(default=None, init=False)
-    _http: aiohttp.ClientSession | None = field(default=None, init=False)
-    _thread_path: str | None = field(default=None, init=False)
-    # Seen message ids PER THREAD — one shared set would let a reused conversation thread
-    # reset a delegated thread's watermark and re-announce an old answer.
-    _known: dict[str, set[str]] = field(default_factory=dict, init=False)
-    _last_used: float = field(default=0.0, init=False)
-
-    async def _post(self, payload: dict) -> tuple[dict, str]:
-        if self._http is None:
-            connector = None if self.verify_tls else aiohttp.TCPConnector(ssl=False)
-            self._http = aiohttp.ClientSession(connector=connector)
-        headers = {
-            "Authorization": f"Bearer {self.token}",
-            "Content-Type": "application/json",
-            "Accept": "application/json, text/event-stream",
-        }
-        if self._session_id:
-            headers["Mcp-Session-Id"] = self._session_id
-        async with self._http.post(
-            f"{self.base_url}/mcp", json=payload, headers=headers,
-            timeout=aiohttp.ClientTimeout(total=120),
-        ) as response:
-            body = await response.text()
-            if response.status >= 400:
-                raise McpError(f"HTTP {response.status}: {body[:300]}")
-            return dict(response.headers), body
-
-    async def _ensure_session(self) -> None:
-        if self._session_id:
-            return
-        head, _ = await self._post({
-            "jsonrpc": "2.0", "id": 1, "method": "initialize",
-            "params": {"protocolVersion": "2025-03-26", "capabilities": {},
-                       "clientInfo": {"name": "memex-voice-gateway", "version": "0.1"}},
-        })
-        self._session_id = head.get("Mcp-Session-Id") or head.get("mcp-session-id")
-        await self._post({"jsonrpc": "2.0", "method": "notifications/initialized"})
-
-    async def call(self, tool: str, arguments: dict) -> str:
-        await self._ensure_session()
-        try:
-            _, body = await self._post({"jsonrpc": "2.0", "id": 9, "method": "tools/call",
-                                        "params": {"name": tool, "arguments": arguments}})
-        except McpError:
-            # One re-init retry: the server may have expired the session between wake words.
-            self._session_id = None
-            await self._ensure_session()
-            _, body = await self._post({"jsonrpc": "2.0", "id": 9, "method": "tools/call",
-                                        "params": {"name": tool, "arguments": arguments}})
-        return parse_tool_result(body)
-
-    async def _snapshot_ids(self, thread_path: str) -> set[str]:
-        node = json.loads(await self.call("get", {"path": f"@{thread_path}"}))
-        return set((node.get("content") or {}).get("messages", []))
-
-    async def delegate(self, text: str, agent: str | None = None) -> str:
-        """Fire-and-forget: launch a NEW thread for a standard agent (Assistant, Researcher,
-        …) and return its path. Deliberately does NOT become the voice conversation thread —
-        the task runs and is evaluated in the portal, not read aloud. CONTINUATION policy
-        (post follow-ups into the open thread) lives in the router's context, not here."""
-        args: dict = {"namespacePath": self.namespace, "message": text}
-        if agent or self.agent:
-            args["agentName"] = agent or self.agent
-        started = json.loads(await self.call("start_thread", args))
-        path = started["threadPath"]
-        self._known[path] = set()
-        return path
-
-    async def submit(self, thread_path: str, text: str, agent: str | None = None) -> str:
-        """Post a follow-up into an EXISTING thread — the context stays. The id watermark is
-        re-snapshotted first so await_reply announces only what lands AFTER this message."""
-        self._known[thread_path] = await self._snapshot_ids(thread_path)
-        args: dict = {"threadPath": thread_path, "message": text}
-        if agent or self.agent:
-            args["agentName"] = agent or self.agent
-        await self.call("submit_message", args)
-        return thread_path
-
-    async def ask(self, text: str) -> str:
-        """Submit an utterance; returns the thread path. Reuses a recent thread for context."""
-        fresh = self._thread_path and (time.monotonic() - self._last_used) < self.thread_idle_minutes * 60
-        if fresh and self._thread_path:
-            await self.submit(self._thread_path, text)
-        else:
-            args = {"namespacePath": self.namespace, "message": text}
-            if self.agent:
-                args["agentName"] = self.agent
-            started = json.loads(await self.call("start_thread", args))
-            self._thread_path = started["threadPath"]
-            self._known[self._thread_path] = set()
-        self._last_used = time.monotonic()
-        return self._thread_path  # type: ignore[return-value]
-
-    async def await_reply(self, thread_path: str, budget_s: float,
-                          poll_interval_s: float = 1.5) -> str | None:
-        """Poll until an assistant reply (or a dispatch failure) lands; None on budget miss."""
-        deadline = time.monotonic() + budget_s
-        known = self._known.setdefault(thread_path, set())
-        interval = poll_interval_s
-        while time.monotonic() < deadline:
-            thread_json = await self.call("get", {"path": f"@{thread_path}"})
-            new_ids, failure = extract_reply(thread_json, known)
-            for message_id in new_ids:
-                child = json.loads(await self.call("get", {"path": f"@{thread_path}/{message_id}"}))
-                content = child.get("content") or {}
-                text = (content.get("text") or "").strip()
-                status = content.get("status")
-                # An assistant child can materialize MID-round as a placeholder
-                # ("Generating response...", status InProgress) whose text is later
-                # replaced by the real answer. Reading it aloud IS the bug (observed
-                # 2026-08-20) — and marking it seen would silence the real answer, so an
-                # in-progress child stays un-known and is re-read on the next poll.
-                if content.get("role") == "assistant":
-                    in_progress = (status not in (None, "Completed")
-                                   or text.lower().startswith("generating"))
-                    if in_progress:
-                        continue
-                    known.add(message_id)
-                    if text:
-                        return content["text"]
-                else:
-                    known.add(message_id)
-            if failure:
-                return failure
-            # Memex is ASYNC: the announce path may wait many minutes, so the poll backs
-            # off gently (up to 10s) instead of hammering the portal every 1.5s for half
-            # an hour. The first polls stay tight so a fast answer arrives fast.
-            await asyncio.sleep(interval)
-            interval = min(interval * 1.3, 10.0)
-        return None
-
-    async def close(self) -> None:
-        if self._http is not None:
-            await self._http.close()
-            self._http = None
diff --git a/clients/voice-gateway/memex_voice_gateway/tts.py b/clients/voice-gateway/memex_voice_gateway/tts.py
deleted file mode 100644
index 13be7ab826..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/tts.py
+++ /dev/null
@@ -1,236 +0,0 @@
-"""Text-to-speech (Piper) plus the tiny HTTP server the satellite fetches audio from.
-
-The ESPHome voice pipeline delivers TTS as a URL in the TTS_END event; the device's media
-player then streams it. So the gateway synthesizes with the Piper CLI and serves the WAV from
-memory for a short TTL. High German out (`de_DE` voices) — the assistant *understands*
-Schwiizerdütsch (the Whisper fine-tune transcribes it to Standard German) and answers in
-Standard German.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import secrets
-import time
-
-from aiohttp import web
-
-
-class PiperTts:
-    def __init__(self, piper_bin: str, voice_path: str) -> None:
-        self.piper_bin = piper_bin
-        self.voice_path = voice_path
-
-    async def synthesize(self, text: str) -> bytes:
-        process = await asyncio.create_subprocess_exec(
-            self.piper_bin, "--model", self.voice_path, "--output_file", "-",
-            stdin=asyncio.subprocess.PIPE,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        wav, err = await process.communicate(text.encode())
-        if process.returncode != 0 or not wav:
-            raise RuntimeError(f"piper failed ({process.returncode}): {err.decode()[:300]}")
-        return wav
-
-
-class SayTts:
-    """macOS's built-in `say` — zero-setup local TTS (voice e.g. "Anna" for German).
-
-    Writes a 16-bit 22.05 kHz WAV to a temp file (say has no stdout mode) and returns
-    its bytes; the temp file is removed immediately.
-    """
-
-    def __init__(self, voice: str = "Anna", english_voice: str = "Samantha") -> None:
-        self.voice = voice
-        self.english_voice = english_voice
-
-    @staticmethod
-    def _looks_german(text: str) -> bool:
-        """Cheap language guess: a German voice reading English sounds awful (and vice
-        versa), so the voice follows the reply's language."""
-        lowered = f" {text.lower()} "
-        german_markers = (" der ", " die ", " das ", " und ", " ist ", " nicht ", " ich ",
-                          " sie ", " mit ", " ein ", " eine ", " zu ", " haben ", " wie ",
-                          "ä", "ö", "ü", "ß")
-        english_markers = (" the ", " is ", " are ", " you ", " and ", " to ", " of ",
-                           " have ", " what ", " it ")
-        g = sum(m in lowered for m in german_markers)
-        e = sum(m in lowered for m in english_markers)
-        return g >= e
-
-    @staticmethod
-    def build_args(voice: str, out_path: str) -> list[str]:
-        # 16 kHz: the satellite firmware micro_decoder rejects 22050 Hz ('Decode finished'
-        # after ~300ms, silent playback — the reason no reply was ever HEARD on it).
-        return ["say", "-v", voice, "-o", out_path, "--data-format=LEI16@16000", "-f", "-"]
-
-    async def synthesize(self, text: str) -> bytes:
-        import os
-        import tempfile
-        fd, path = tempfile.mkstemp(suffix=".wav")
-        os.close(fd)
-        try:
-            voice = self.voice if self._looks_german(text) else self.english_voice
-            process = await asyncio.create_subprocess_exec(
-                *self.build_args(voice, path),
-                stdin=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
-            _, err = await process.communicate(text.encode())
-            if process.returncode != 0:
-                raise RuntimeError(f"say failed ({process.returncode}): {err.decode()[:200]}")
-            with open(path, "rb") as f:
-                return f.read()
-        finally:
-            try:
-                os.unlink(path)
-            except OSError:
-                pass
-
-
-def split_wav(wav: bytes) -> tuple[bytes, int]:
-    """(pcm, sample_rate) out of a RIFF/WAVE blob — walks the chunks, no fixed 44-byte guess."""
-    if wav[:4] != b"RIFF" or wav[8:12] != b"WAVE":
-        raise ValueError("not a RIFF/WAVE blob")
-    rate, offset = 16000, 12
-    while offset + 8 <= len(wav):
-        cid = wav[offset:offset + 4]
-        size = int.from_bytes(wav[offset + 4:offset + 8], "little")
-        if cid == b"fmt ":
-            rate = int.from_bytes(wav[offset + 12:offset + 16], "little")
-        elif cid == b"data":
-            return wav[offset + 8:offset + 8 + size], rate
-        offset += 8 + size + (size & 1)
-    raise ValueError("no data chunk")
-
-
-def streaming_wav_header(sample_rate: int, channels: int = 1) -> bytes:
-    """A WAV header that promises 'read until EOF' — sizes maxed, for chunked streaming."""
-    import struct
-    byte_rate = sample_rate * channels * 2
-    header = b"RIFF" + struct.pack("<I", 0xFFFFFFFF) + b"WAVE"
-    header += b"fmt " + struct.pack("<IHHIIHH", 16, 1, channels, sample_rate, byte_rate, channels * 2, 16)
-    header += b"data" + struct.pack("<I", 0xFFFFFFFF - 44)
-    return header
-
-
-class StreamingWav:
-    """One in-flight streamed utterance. PCM sentences are BUFFERED as they arrive, and any
-    number of readers replay the buffer then follow the live tail — the device's player
-    sniffs the URL (a short first request) and then re-requests it for actual playback, so
-    a single-use stream plays as silence (observed: 200-byte fetches, then nothing)."""
-
-    def __init__(self, sample_rate: int) -> None:
-        self.sample_rate = sample_rate
-        self.chunks: list[bytes] = []
-        self.closed = False
-        self._changed = asyncio.Condition()
-
-    async def push(self, pcm: bytes) -> None:
-        async with self._changed:
-            self.chunks.append(pcm)
-            self._changed.notify_all()
-
-    async def close(self) -> None:
-        async with self._changed:
-            self.closed = True
-            self._changed.notify_all()
-
-    async def read_from(self, index: int) -> bytes | None:
-        """The chunk at `index`, waiting for it if the stream is still being fed;
-        None once the stream is closed and fully consumed."""
-        async with self._changed:
-            while index >= len(self.chunks) and not self.closed:
-                await self._changed.wait()
-            return self.chunks[index] if index < len(self.chunks) else None
-
-
-class TtsFileServer:
-    """Serves synthesized WAVs at /tts/{id}.wav from memory, expiring after `ttl_s` —
-    and chunked live streams at /tts-stream/{id}.wav (see StreamingWav)."""
-
-    def __init__(self, host: str, port: int, ttl_s: float = 300.0) -> None:
-        self.host = host
-        self.port = port
-        self.ttl_s = ttl_s
-        self._files: dict[str, tuple[float, bytes]] = {}
-        self._streams: dict[str, StreamingWav] = {}
-        self._live: set[StreamingWav] = set()
-        self._runner: web.AppRunner | None = None
-
-    def open_stream(self, sample_rate: int) -> tuple[StreamingWav, str]:
-        # Expire finished streams by TTL (they stay addressable for the player's re-request).
-        now = time.monotonic()
-        self._stream_born = getattr(self, "_stream_born", {})
-        for sid in [sid for sid, born in self._stream_born.items() if now - born > self.ttl_s]:
-            self._streams.pop(sid, None); self._stream_born.pop(sid, None)
-        stream = StreamingWav(sample_rate)
-        stream_id = secrets.token_urlsafe(8)
-        self._streams[stream_id] = stream
-        self._stream_born[stream_id] = now
-        self._live.add(stream)
-        return stream, f"http://{self.host}:{self.port}/tts-stream/{stream_id}.wav"
-
-    async def interrupt_streams(self) -> None:
-        """Barge-in: close every live stream so its playback drains out within a second."""
-        for stream in list(self._live):
-            await stream.close()
-        self._live.clear()
-
-    async def _handle_stream(self, request: web.Request) -> web.StreamResponse:
-        stream = self._streams.get(request.match_info["id"])
-        if stream is None:
-            return web.Response(status=404)
-        response = web.StreamResponse(headers={"Content-Type": "audio/wav"})
-        response.enable_chunked_encoding()
-        await response.prepare(request)
-        await response.write(streaming_wav_header(stream.sample_rate))
-        index = 0
-        try:
-            while (pcm := await stream.read_from(index)) is not None:
-                index += 1
-                await response.write(pcm)
-            await response.write_eof()
-        finally:
-            if stream.closed:
-                self._live.discard(stream)
-        return response
-
-    @staticmethod
-    def _wav_to_flac(wav: bytes) -> bytes:
-        """The satellite's micro_decoder ships WITHOUT the WAV codec (its own config:
-        'FLAC is the least processor intensive') — Home Assistant transcodes announcements
-        to the device's announced format, and so must we."""
-        import subprocess
-        r = subprocess.run(["ffmpeg", "-loglevel", "error", "-f", "wav", "-i", "pipe:0",
-                            "-f", "flac", "-compression_level", "0", "pipe:1"],
-                           input=wav, capture_output=True)
-        if r.returncode != 0 or not r.stdout:
-            raise RuntimeError(f"flac transcode failed: {r.stderr.decode()[:200]}")
-        return r.stdout
-
-    def add(self, wav: bytes) -> str:
-        now = time.monotonic()
-        self._files = {k: v for k, v in self._files.items() if now - v[0] < self.ttl_s}
-        file_id = secrets.token_urlsafe(8)
-        self._files[file_id] = (now, self._wav_to_flac(wav))
-        return f"http://{self.host}:{self.port}/tts/{file_id}.flac"
-
-    async def _handle(self, request: web.Request) -> web.Response:
-        entry = self._files.get(request.match_info["id"])
-        if entry is None:
-            return web.Response(status=404)
-        return web.Response(body=entry[1], content_type="audio/flac")
-
-    async def start(self) -> None:
-        app = web.Application()
-        app.router.add_get("/tts/{id}.flac", self._handle)
-        app.router.add_get("/tts-stream/{id}.wav", self._handle_stream)
-        self._runner = web.AppRunner(app)
-        await self._runner.setup()
-        site = web.TCPSite(self._runner, "0.0.0.0", self.port)
-        await site.start()
-
-    async def stop(self) -> None:
-        if self._runner is not None:
-            await self._runner.cleanup()
-            self._runner = None
diff --git a/clients/voice-gateway/memex_voice_gateway/vad.py b/clients/voice-gateway/memex_voice_gateway/vad.py
deleted file mode 100644
index f5b5899693..0000000000
--- a/clients/voice-gateway/memex_voice_gateway/vad.py
+++ /dev/null
@@ -1,94 +0,0 @@
-"""End-of-utterance detection over the satellite's 16 kHz mono s16le stream.
-
-Energy-based endpointing with an adaptive noise floor — no model, no native deps, fully
-unit-testable. The device's XMOS pipeline already gives us clean, echo-cancelled audio, so a
-simple RMS gate is enough to find the end of speech; swap in a model VAD later if dialect
-pauses prove too long for a fixed silence window.
-"""
-
-from __future__ import annotations
-
-import struct
-from dataclasses import dataclass
-
-
-def rms(frame: bytes) -> float:
-    """Root mean square of a 16-bit little-endian PCM frame. Empty frame → 0."""
-    n = len(frame) // 2
-    if n == 0:
-        return 0.0
-    samples = struct.unpack(f"<{n}h", frame[: n * 2])
-    return (sum(s * s for s in samples) / n) ** 0.5
-
-
-@dataclass
-class Endpointer:
-    """Feed PCM chunks; `done` flips true one silence-window after speech ended.
-
-    The threshold adapts: the noise floor is the running minimum of recent frame energy,
-    and speech is anything a fixed factor above it. This survives both a quiet room and a
-    fan next to the mic without per-site tuning.
-    """
-
-    sample_rate: int = 16000
-    silence_ms: int = 800
-    max_utterance_s: float = 15.0
-    min_utterance_s: float = 0.4
-    speech_factor: float = 3.0
-    floor_init: float = 150.0
-    calibrate_ms: int = 0       # treat the first N ms as ambient (TV, music) — floor, not speech
-    onset_timeout_s: float = 0  # 0 = off; else end early when no speech starts in time
-
-    def __post_init__(self) -> None:
-        self._buffer = bytearray()
-        self._noise_floor = self.floor_init
-        self._speech_seen = False
-        self._silence_bytes = 0
-        self._speech_bytes = 0
-        self.done = False
-        self.ended_by_cap = False   # True = closed by max duration, NOT by a silence gap
-        self.speech_seen = False
-
-    @property
-    def audio(self) -> bytes:
-        return bytes(self._buffer)
-
-    def _bytes_per_ms(self) -> float:
-        return self.sample_rate * 2 / 1000.0
-
-    def feed(self, chunk: bytes) -> bool:
-        """Accumulate a chunk; returns True once the utterance is complete."""
-        if self.done or not chunk:
-            return self.done
-        self._buffer.extend(chunk)
-
-        level = rms(chunk)
-        # Ambient calibration window (follow-up rounds): whatever is audible right when the
-        # mic opens — a TV, music — is the FLOOR, not speech; only louder-than-that counts.
-        if len(self._buffer) <= self.calibrate_ms * self._bytes_per_ms():
-            self._noise_floor = max(self._noise_floor, level)
-            return self.done
-        # Track the floor down fast, up slowly — a shout must not raise it.
-        if level < self._noise_floor:
-            self._noise_floor = max(1.0, 0.5 * self._noise_floor + 0.5 * level)
-        else:
-            self._noise_floor = 0.995 * self._noise_floor + 0.005 * level
-
-        if level > self._noise_floor * self.speech_factor:
-            self._speech_seen = True
-            self._speech_bytes += len(chunk)
-            self._silence_bytes = 0
-        elif self._speech_seen:
-            self._silence_bytes += len(chunk)
-
-        long_enough = self._speech_bytes >= self.min_utterance_s * self.sample_rate * 2
-        silent_long = self._silence_bytes >= self.silence_ms * self._bytes_per_ms()
-        too_long = len(self._buffer) >= self.max_utterance_s * self.sample_rate * 2
-        no_onset = (self.onset_timeout_s > 0 and not self._speech_seen
-                    and len(self._buffer) >= self.onset_timeout_s * self.sample_rate * 2)
-
-        if (self._speech_seen and long_enough and silent_long) or too_long or no_onset:
-            self.done = True
-            self.ended_by_cap = too_long or no_onset
-            self.speech_seen = self._speech_seen
-        return self.done
diff --git a/clients/voice-gateway/pyproject.toml b/clients/voice-gateway/pyproject.toml
deleted file mode 100644
index 82d48c4136..0000000000
--- a/clients/voice-gateway/pyproject.toml
+++ /dev/null
@@ -1,25 +0,0 @@
-[build-system]
-requires = ["setuptools>=68"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "memex-voice-gateway"
-version = "0.1.0"
-description = "Standalone voice gateway: an ESPHome voice satellite (e.g. FutureProofHomes Satellite1) wired directly to MeshWeaver agent threads — no Home Assistant required."
-requires-python = ">=3.11"
-dependencies = [
-    "aioesphomeapi>=30.0",
-    "aiohttp>=3.9",
-]
-
-[project.optional-dependencies]
-dev = ["pytest>=8", "pytest-asyncio>=0.23"]
-
-[project.scripts]
-memex-voice-gateway = "memex_voice_gateway.__main__:main"
-
-[tool.setuptools.packages.find]
-include = ["memex_voice_gateway*"]
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
diff --git a/clients/voice-gateway/run-local.sh b/clients/voice-gateway/run-local.sh
deleted file mode 100755
index 40e0d99e87..0000000000
--- a/clients/voice-gateway/run-local.sh
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/bin/sh
-# All-local run on a Mac: whisper.cpp STT + Ollama brain + macOS `say` TTS.
-# Prereqs: brew install whisper-cpp ollama; the Swiss German GGML in ~/models/whisper/
-# (voice-model-swiss-german release on the PRIVATE MeshWeaver.Plugins repo — gh auth); an Ollama model pulled (default qwen3.6).
-# Required env: SATELLITE_HOST, SATELLITE_PSK, GATEWAY_HOST (this Mac's LAN IP).
-set -e
-
-WHISPER_MODEL="${WHISPER_MODEL:-$HOME/models/whisper/ggml-swiss-german-turbo-q5_0.bin}"
-WHISPER_PORT="${WHISPER_PORT:-8090}"
-
-if ! curl -sf "http://127.0.0.1:${WHISPER_PORT}/" >/dev/null 2>&1; then
-    echo "Starting whisper-server on :${WHISPER_PORT} (${WHISPER_MODEL})"
-    whisper-server -m "$WHISPER_MODEL" --port "$WHISPER_PORT" --host 127.0.0.1 &
-    sleep 2
-fi
-
-export BRAIN="${BRAIN:-ollama}"
-export OLLAMA_MODEL="${OLLAMA_MODEL:-qwen3.6}"
-export STT_URL="${STT_URL:-http://127.0.0.1:${WHISPER_PORT}/inference}"
-export TTS_ENGINE="${TTS_ENGINE:-say}"
-export SAY_VOICE="${SAY_VOICE:-Anna}"
-
-exec python -m memex_voice_gateway
diff --git a/clients/voice-gateway/tests/test_context.py b/clients/voice-gateway/tests/test_context.py
deleted file mode 100644
index 26f0d8c668..0000000000
--- a/clients/voice-gateway/tests/test_context.py
+++ /dev/null
@@ -1,202 +0,0 @@
-"""The spoken context: sticky threads, switching, the session cookie."""
-import asyncio
-import time
-
-from memex_voice_gateway.router import BrainRouter
-from memex_voice_gateway.session import SpokenSession
-
-
-class FakeMesh:
-    def __init__(self):
-        self.started, self.submitted = [], []
-        self.counter = 0
-
-    async def ask(self, text): return "h"
-    async def await_reply(self, handle, budget_s): return None
-    async def close(self): pass
-
-    async def delegate(self, text, agent=None):
-        self.counter += 1
-        self.started.append((text, agent))
-        return f"u/_Thread/t{self.counter}"
-
-    async def submit(self, path, text, agent=None):
-        self.submitted.append((path, text, agent))
-        return path
-
-
-def test_context_sticks_until_switched_or_closed():
-    async def scenario():
-        mesh = FakeMesh()
-        router = BrainRouter({"memex": mesh}, "memex")
-        # First delegation opens the thread and SETS the context.
-        h1 = await router.delegate_task("Wetter morgen in Zürich")
-        assert h1 == "memex::u/_Thread/t1" and len(mesh.started) == 1
-        # The follow-up POSTS INTO the same thread — no new thread.
-        h2 = await router.delegate_task("Und übermorgen?")
-        assert h2 == h1 and len(mesh.started) == 1
-        assert mesh.submitted[0][0] == "u/_Thread/t1"
-        # A different explicit agent gets its own thread; context switches to it.
-        h3 = await router.delegate_task("Check my inbox", "ExecutiveAssistant")
-        assert h3 == "memex::u/_Thread/t2"
-        # …and now follow-ups continue THERE.
-        h4 = await router.delegate_task("Reply to the first one")
-        assert h4 == h3
-        # "neues Thema" clears the context: the next delegation opens thread 3.
-        assert await router.handle_command("Neues Thema") == "Okay, new topic."
-        h5 = await router.delegate_task("Plan my week")
-        assert h5 == "memex::u/_Thread/t3"
-
-    asyncio.run(scenario())
-
-
-def test_spoken_switch_and_post_by_topic():
-    async def scenario():
-        mesh = FakeMesh()
-        router = BrainRouter({"memex": mesh}, "memex")
-        weather = await router.delegate_task("Wetter morgen in Zürich")
-        await router.handle_command("Neues Thema")
-        mail = await router.delegate_task("Fasse meine Mails zusammen", "ExecutiveAssistant")
-        assert weather != mail
-        # Switch back by topic — context returns to the weather thread.
-        out = await router.handle_command("Wechsle zum Thread über Wetter")
-        assert "Wetter" in out
-        assert (await router.delegate_task("Regnet es?")) == weather
-        # Post into the OTHER thread by topic without switching a delegation there first.
-        out = await router.handle_command("Im Thread über Mails: bitte die von Anna zuerst")
-        assert "Mails" in out
-        assert mesh.submitted[-1][0] == mail.partition("::")[2]
-        # …and the answer is queued for announcement.
-        pending = router.drain_delegations()
-        assert pending and pending[0][0] == mail
-        # Listing names both threads.
-        listed = await router.handle_command("Welche Threads sind offen?")
-        assert "Wetter" in listed and "Mails" in listed
-
-    asyncio.run(scenario())
-
-
-def test_session_cookie_roundtrip_and_expiry(tmp_path):
-    store = SpokenSession(str(tmp_path / "session.json"), ttl_hours=8)
-    store.save(portal="memex", context={"portal": "memex", "path": "u/_Thread/t1",
-                                        "task": "Wetter", "agent": ""},
-               threads=[{"portal": "memex", "path": "u/_Thread/t1", "task": "Wetter",
-                         "agent": "", "last": time.time()}])
-    state = store.load()
-    assert state["portal"] == "memex" and state["context"]["path"] == "u/_Thread/t1"
-
-    async def scenario():
-        mesh = FakeMesh()
-        router = BrainRouter({"memex": mesh}, "memex")
-        router.restore(state)
-        # The restored context is live: a delegation posts into the persisted thread.
-        assert (await router.delegate_task("Und heute?")) == "memex::u/_Thread/t1"
-        assert mesh.submitted and not mesh.started
-
-    asyncio.run(scenario())
-    # An expired cookie loads as a clean session.
-    expired = SpokenSession(str(tmp_path / "expired.json"), ttl_hours=-1)
-    expired.save(portal="memex", context=None, threads=[])
-    assert expired.load() == {}
-
-
-def test_mesh_tool_passthrough_gates_destructive():
-    class ToolMesh(FakeMesh):
-        def __init__(self):
-            super().__init__()
-            self.calls = []
-        async def call(self, tool, arguments):
-            self.calls.append((tool, arguments))
-            return "ok"
-
-    async def scenario():
-        mesh = ToolMesh()
-        router = BrainRouter({"memex": mesh}, "memex")
-        assert await router.run_tool("mesh_tool", {"tool": "render_area",
-                                                   "arguments": {"path": "@X"}}) == "ok"
-        out = await router.run_tool("mesh_tool", {"tool": "delete",
-                                                  "arguments": {"path": "@X"}})
-        assert "destructive" in out and ("delete", {"path": "@X"}) not in mesh.calls
-        router.allow_destructive = True
-        assert await router.run_tool("mesh_tool", {"tool": "delete",
-                                                   "arguments": {"path": "@X"}}) == "ok"
-
-    asyncio.run(scenario())
-
-
-def test_mailbox_signal_then_read_aloud():
-    async def scenario():
-        mesh = FakeMesh()
-        router = BrainRouter({"memex": mesh}, "memex")
-        handle = await router.delegate_task("Wetter morgen in Zürich")
-        await router.handle_command("Neues Thema")
-        # The answer lands: only a short READY signal is spoken; the text waits.
-        signal = router.deliver_answer(handle, "Wetter morgen in Zürich",
-                                       "Morgen wird es sonnig bei 24 Grad.")
-        assert "ready" in signal.lower() or "bereit" in signal.lower()
-        # …and the answered thread is pinned back as the context for follow-ups.
-        assert (await router.delegate_task("Und übermorgen?")) == handle
-        # "vorlesen" plays the stored answer, attributed to its question.
-        out = await router.handle_command("Vorlesen")
-        assert "sonnig" in out and "Wetter morgen" in out
-        # The mailbox is empty afterwards.
-        assert await router.handle_command("Lies vor") == router._phrases["nothing_new"]
-
-    asyncio.run(scenario())
-
-
-def test_email_routes_deterministically_to_executive_assistant():
-    async def scenario():
-        mesh = FakeMesh()
-        router = BrainRouter({"memex": mesh}, "memex",
-                             agent_homes={"ExecutiveAssistant": "memex"})
-        out = await router.handle_command("Kannst du meine Mails checken?")
-        assert out is not None and "memex" in out
-        assert mesh.started == [("Kannst du meine Mails checken?", "ExecutiveAssistant")]
-        # The answer is queued for the mailbox/announce path.
-        assert router.drain_delegations()
-        # Unrelated sentences pass through to the brain untouched.
-        assert await router.handle_command("Wie spät ist es?") is None
-
-    asyncio.run(scenario())
-
-
-def test_system_prompt_syncs_from_mesh_or_deposits():
-    import json as _json
-
-    class PromptMesh(FakeMesh):
-        def __init__(self, body=None):
-            super().__init__()
-            self.namespace = "rbuergi"
-            self.body = body
-            self.created = []
-        async def call(self, tool, arguments):
-            if tool == "get":
-                if self.body is None:
-                    raise RuntimeError("not found")
-                return _json.dumps({"content": {"$type": "MarkdownContent", "body": self.body}})
-            if tool == "create":
-                self.created.append(_json.loads(arguments["node"]))
-                return "{}"
-            raise AssertionError(tool)
-
-    async def scenario():
-        # A prompt node in the mesh WINS over the built-in.
-        mesh = PromptMesh(body="Du bist Memex, kurz und knapp.")
-        router = BrainRouter({"memex": mesh}, "memex")
-        assert await router.sync_system_prompt("BUILTIN") == "Du bist Memex, kurz und knapp."
-        # No node → the built-in is DEPOSITED for the user to edit, and used as-is.
-        mesh2 = PromptMesh(body=None)
-        router2 = BrainRouter({"memex": mesh2}, "memex")
-        assert await router2.sync_system_prompt("BUILTIN") == "BUILTIN"
-        deposited = mesh2.created[0]
-        assert deposited["namespace"] == "rbuergi/Voice" and deposited["id"] == "Prompt"
-        assert deposited["content"]["body"] == "BUILTIN"
-
-    asyncio.run(scenario())
-
-
-def test_session_cookie_accepts_growing_state(tmp_path):
-    store = SpokenSession(str(tmp_path / "s.json"), ttl_hours=8)
-    store.save(portal="memex", context=None, threads=[], inbox=[{"task": "t", "reply": "r"}])
-    assert store.load()["inbox"][0]["reply"] == "r"
diff --git a/clients/voice-gateway/tests/test_ollama.py b/clients/voice-gateway/tests/test_ollama.py
deleted file mode 100644
index b0860d20ae..0000000000
--- a/clients/voice-gateway/tests/test_ollama.py
+++ /dev/null
@@ -1,127 +0,0 @@
-import asyncio
-
-from memex_voice_gateway.ollama import SYSTEM_PROMPT, OllamaBrain, build_messages
-
-
-def test_build_messages_prepends_system_and_trims_history():
-    history = [{"role": "user", "content": f"q{i}"} for i in range(30)]
-    messages = build_messages(history, "neu", max_turns=2)
-    assert messages[0] == {"role": "system", "content": SYSTEM_PROMPT}
-    assert len(messages) == 1 + 4 + 1  # system + last 2*2 history + new user message
-    assert messages[-1] == {"role": "user", "content": "neu"}
-
-
-def test_budget_miss_leaves_generation_running_and_second_wait_succeeds():
-    async def scenario():
-        brain = OllamaBrain("http://unused", "test-model")
-        release = asyncio.Event()
-
-        async def slow_chat(messages, handle=None):
-            await release.wait()
-            return "Die Antwort."
-
-        brain._chat = slow_chat  # inject a fake transport
-        handle = await brain.ask("Frage?")
-        assert await brain.await_reply(handle, 0.05) is None  # budget missed, still running
-        release.set()
-        reply = await brain.await_reply(handle, 1.0)          # announce path retries the handle
-        assert reply == "Die Antwort."
-        assert brain._history[-1] == {"role": "assistant", "content": "Die Antwort."}
-        await brain.close()
-
-    asyncio.run(scenario())
-
-
-def test_history_resets_after_idle_window():
-    async def scenario():
-        brain = OllamaBrain("http://unused", "test-model", idle_minutes=0)
-
-        async def chat(messages, handle=None):
-            return "ok"
-
-        brain._chat = chat
-        first = await brain.ask("erste Frage")
-        await brain.await_reply(first, 1.0)
-        brain._last_used -= 1  # idle_minutes=0 → any elapsed time exceeds the window
-        await brain.ask("zweite Frage")
-        assert [m["content"].split("] ", 1)[1] for m in brain._history] == ["zweite Frage"]
-        await brain.close()
-
-    asyncio.run(scenario())
-
-
-def test_real_time_anchor_in_messages():
-    import datetime
-    from memex_voice_gateway.ollama import now_line
-    stamp = now_line(datetime.datetime(2026, 8, 18, 21, 30))
-    assert stamp == "Current time: Tuesday, 18 August 2026, 21:30."
-    messages = build_messages([], "[21:30] Frage", now=stamp)
-    assert stamp in messages[0]["content"] and messages[0]["role"] == "system"
-
-
-def test_triage_delegates_and_collects_pending():
-    async def scenario():
-        brain = OllamaBrain("http://unused", "test-model")
-        delegated = []
-
-        async def delegator(task, agent=None):
-            delegated.append((task, agent))
-            return f"memex::u/_Thread/t{len(delegated)}"
-
-        brain.delegator = delegator
-
-        async def fake_streaming(messages, handle):
-            queue = brain._chunks[handle]
-            # emulate: model tool-calls, then (after the tool result) speaks the handoff
-            if not any(m.get("role") == "tool" for m in messages):
-                pass  # the real loop feeds tools within one call; simulate final directly
-            await queue.put("Memex ist dran und meldet sich.")
-            brain._pending.append(("memex::u/_Thread/t1", "Wetter morgen"))
-            await queue.put(None)
-            return "Memex ist dran und meldet sich."
-
-        brain._chat_streaming = fake_streaming
-        handle = await brain.ask("Wie wird das Wetter morgen?")
-        reply = await brain.await_reply(handle, 1.0)
-        assert reply == "Memex ist dran und meldet sich."
-        assert brain.drain_delegations() == [("memex::u/_Thread/t1", "Wetter morgen")]
-        assert brain.drain_delegations() == []
-        await brain.close()
-
-    asyncio.run(scenario())
-
-
-def test_dispatch_tool_routes_delegate_and_quick_tools():
-    async def scenario():
-        brain = OllamaBrain("http://unused", "test-model")
-        calls = []
-
-        async def delegator(task, agent=None):
-            calls.append(("delegate", task, agent))
-            return "memex::u/_Thread/t1"
-
-        async def tool_runner(name, args):
-            calls.append((name, args))
-            return "x" * 2000 if name == "search_mesh" else "state: on"
-
-        brain.delegator = delegator
-        brain.tool_runner = tool_runner
-
-        out = await brain._dispatch_tool({"function": {
-            "name": "delegate_to_memex",
-            "arguments": {"task": "Wetter morgen", "agent": "Voice"}}})
-        assert "announced" in out
-        assert brain.drain_delegations() == [("memex::u/_Thread/t1", "Wetter morgen")]
-
-        out = await brain._dispatch_tool({"function": {
-            "name": "search_mesh", "arguments": '{"query": "kantone"}'}})
-        assert out.endswith("…(truncated)") and len(out) < 2000
-
-        out = await brain._dispatch_tool({"function": {
-            "name": "home_assistant", "arguments": {"action": "get_state"}}})
-        assert out == "state: on"
-        assert calls[0] == ("delegate", "Wetter morgen", "Voice")
-        assert calls[1] == ("search_mesh", {"query": "kantone"})
-        await brain.close()
-
-    asyncio.run(scenario())
diff --git a/clients/voice-gateway/tests/test_pipeline.py b/clients/voice-gateway/tests/test_pipeline.py
deleted file mode 100644
index 7020c21b0c..0000000000
--- a/clients/voice-gateway/tests/test_pipeline.py
+++ /dev/null
@@ -1,80 +0,0 @@
-import asyncio
-
-from memex_voice_gateway.pipeline import VoicePipeline
-
-
-def make_pipeline(**overrides):
-    calls = {"announced": [], "spoken": []}
-
-    async def transcribe(pcm):
-        return overrides.get("transcript", "wie spät ist es")
-
-    async def ask(text):
-        return "u/_Thread/t1"
-
-    async def await_reply(path, budget):
-        return overrides.get("reply", "Es ist drei Uhr.")
-
-    async def speak(text):
-        calls["spoken"].append(text)
-        return f"http://gw/tts/{len(calls['spoken'])}.wav"
-
-    async def announce(url, text):
-        calls["announced"].append(text)
-
-    pipeline = VoicePipeline(
-        transcribe=overrides.get("transcribe", transcribe),
-        ask=overrides.get("ask", ask),
-        await_reply=overrides.get("await_reply", await_reply),
-        speak=speak, announce=announce,
-        reply_budget_s=0.05, announce_budget_s=0.2,
-        hold_phrase="Moment bitte.", error_phrase="Fehler.",
-    )
-    return pipeline, calls
-
-
-def test_inline_reply_within_budget():
-    pipeline, calls = make_pipeline()
-    result = asyncio.run(pipeline.run(b"pcm"))
-    assert result.reply == "Es ist drei Uhr."
-    assert result.tts_url and calls["spoken"] == ["Es ist drei Uhr."]
-    assert calls["announced"] == []
-
-
-def test_budget_miss_holds_then_announces():
-    attempts = []
-
-    async def slow_reply(path, budget):
-        attempts.append(budget)
-        if len(attempts) == 1:
-            return None            # inline budget missed
-        return "Die Antwort."      # background poll succeeds
-
-    async def scenario():
-        pipeline, calls = make_pipeline(await_reply=slow_reply)
-        result = await pipeline.run(b"pcm")
-        assert result.reply is None
-        assert calls["spoken"] == ["Moment bitte."]
-        await asyncio.gather(*pipeline._background)
-        return calls
-
-    calls = asyncio.run(scenario())
-    assert calls["announced"] == ["Die Antwort."]
-    assert calls["spoken"] == ["Moment bitte.", "Die Antwort."]
-
-
-def test_empty_transcript_ends_quietly():
-    pipeline, calls = make_pipeline(transcript="")
-    result = asyncio.run(pipeline.run(b"pcm"))
-    assert result.reply is None and result.tts_url is None
-    assert calls["spoken"] == [] and calls["announced"] == []
-
-
-def test_stt_failure_speaks_error_phrase():
-    async def broken(pcm):
-        raise RuntimeError("stt down")
-
-    pipeline, calls = make_pipeline(transcribe=broken)
-    result = asyncio.run(pipeline.run(b"pcm"))
-    assert result.reply == "Fehler."
-    assert calls["spoken"] == ["Fehler."]
diff --git a/clients/voice-gateway/tests/test_router.py b/clients/voice-gateway/tests/test_router.py
deleted file mode 100644
index 56c0640fce..0000000000
--- a/clients/voice-gateway/tests/test_router.py
+++ /dev/null
@@ -1,243 +0,0 @@
-import asyncio
-
-from memex_voice_gateway.router import BrainRouter, parse_switch_command
-
-
-def test_parse_switch_variants():
-    assert parse_switch_command("Wechsle zu Systemorph.") == "Systemorph"
-    assert parse_switch_command("switch to memex") == "memex"
-    assert parse_switch_command("Verbinde mit lokal!") == "lokal"
-    assert parse_switch_command("gang uf systemorph") == "systemorph"
-    assert parse_switch_command("Wie viele Kantone hat die Schweiz?") is None
-    assert parse_switch_command("Wechsle zu was auch immer du willst bitte jetzt") \
-        == "was auch immer du willst bitte jetzt"
-
-
-class FakeBrain:
-    def __init__(self, tag):
-        self.tag = tag
-        self.asked = []
-
-    async def ask(self, text):
-        self.asked.append(text)
-        return f"h-{self.tag}"
-
-    async def await_reply(self, handle, budget_s):
-        return f"{self.tag} answered {handle}"
-
-    async def close(self):
-        pass
-
-
-def test_switch_and_routing_with_stamped_handles():
-    async def scenario():
-        memex, local = FakeBrain("memex"), FakeBrain("lokal")
-        router = BrainRouter({"memex": memex, "lokal": local}, "memex")
-
-        assert await router.handle_command("Wie spät ist es?") is None
-        handle = await router.ask("frage eins")
-        assert handle == "memex::h-memex"
-
-        assert await router.handle_command("wechsle zu lokal") == "Connected to lokal."
-        assert router.active == "lokal"
-        await router.ask("frage zwei")
-        assert local.asked == ["frage zwei"]
-
-        # a handle from BEFORE the switch still polls the brain that produced it
-        assert await router.await_reply(handle, 1.0) == "memex answered h-memex"
-
-        unknown = await router.handle_command("wechsle zu atlantis")
-        assert "atlantis" in unknown and "memex" in unknown
-
-    asyncio.run(scenario())
-
-
-def test_resolve_is_forgiving():
-    router = BrainRouter({"systemorph": FakeBrain("s"), "memex": FakeBrain("m")}, "memex")
-    assert router.resolve("Systemorph") == "systemorph"
-    assert router.resolve("system") == "systemorph"
-    assert router.resolve("nothing") is None
-
-
-def test_delegation_to_a_standard_agent():
-    async def scenario():
-        class MeshBrain(FakeBrain):
-            def __init__(self):
-                super().__init__("memex")
-                self.delegated = []
-
-            async def delegate(self, text, agent=None):
-                self.delegated.append((agent, text))
-                return "u/_Thread/task-1"
-
-        mesh, local = MeshBrain(), FakeBrain("lokal")
-        router = BrainRouter({"lokal": local, "memex": mesh}, "lokal")
-        reply = await router.handle_command("Frag den Researcher nach dem Wetter von morgen")
-        assert "Researcher" in reply and "memex" in reply
-        assert mesh.delegated == [("Researcher", "dem Wetter von morgen")]
-        assert await router.handle_command("Fragen kostet nichts") is None  # not a delegation
-        assert router.describe_hold("memex::x").startswith("Submitted to memex")
-        assert router.describe_hold("lokal::x") == "Let me check. One moment please."
-
-    asyncio.run(scenario())
-
-
-def test_run_tool_dispatches_to_mesh_and_home():
-    class FakeMesh:
-        def __init__(self):
-            self.calls = []
-        async def ask(self, text): return "h"
-        async def await_reply(self, handle, budget_s): return None
-        async def delegate(self, text, agent=None): return "u/_Thread/t1"
-        async def call(self, tool, arguments):
-            self.calls.append((tool, arguments))
-            return f"{tool}-result"
-        async def close(self): pass
-
-    class FakeHome:
-        async def run(self, args): return f"home:{args['action']}"
-        async def close(self): pass
-
-    async def scenario():
-        mesh = FakeMesh()
-        router = BrainRouter({"memex": mesh}, "memex", home=FakeHome())
-        assert await router.run_tool("search_mesh", {"query": "kantone"}) == "search-result"
-        assert await router.run_tool("get_node", {"path": "@Edu/Guide"}) == "get-result"
-        assert await router.run_tool("home_assistant", {"action": "get_state"}) == "home:get_state"
-        assert mesh.calls == [("search", {"query": "kantone", "limit": 8}),
-                              ("get", {"path": "@Edu/Guide"})]
-        bare = BrainRouter({"memex": mesh}, "memex")
-        assert "not configured" in await bare.run_tool("home_assistant", {"action": "get_state"})
-        await router.close()
-
-    asyncio.run(scenario())
-
-
-def test_delegate_routes_agent_to_its_home_portal():
-    class FakeMesh:
-        def __init__(self):
-            self.delegated = []
-        async def ask(self, text): return "h"
-        async def await_reply(self, handle, budget_s): return None
-        async def delegate(self, text, agent=None):
-            self.delegated.append((text, agent))
-            return "u/_Thread/t1"
-        async def close(self): pass
-
-    async def scenario():
-        cloud, mac = FakeMesh(), FakeMesh()
-        router = BrainRouter({"memex": cloud, "mac": mac}, "memex",
-                             agent_homes={"ExecutiveAssistant": "mac"})
-        # Email agent goes HOME to the local mesh, even while the cloud is active.
-        handle = await router.delegate_task("Check my inbox", "ExecutiveAssistant")
-        assert handle.startswith("mac::") and mac.delegated and not cloud.delegated
-        # Unpinned agents keep going to the active mesh.
-        handle = await router.delegate_task("Research quantum", "Researcher")
-        assert handle.startswith("memex::") and cloud.delegated
-
-    asyncio.run(scenario())
-
-
-def test_music_commands_play_and_are_honest_about_songs():
-    class FakeBrainOnly:
-        async def ask(self, text): return "h"
-        async def await_reply(self, handle, budget_s): return None
-        async def close(self): pass
-
-    async def scenario():
-        played = []
-        router = BrainRouter({"lokal": FakeBrainOnly()}, "lokal",
-                             phrases={"radio_on": "Hier kommt {station}.",
-                                      "song_hint": "Einzelne Lieder kann ich noch nicht — dafür kommt {station}."})
-        # Stations are USER DATA loaded from {user}/Voice/Station nodes, never code.
-        router.stations = {
-            "energy zürich": ("Energy Zürich", "https://example.test/energy.mp3"),
-            "radio srf 3": ("Radio SRF 3", "https://example.test/srf3/mp3/128"),
-            "radio srf 1": ("Radio SRF 1", "https://example.test/srf1/mp3/128"),
-        }
-        async def player(url): played.append(url)
-        router.player = player
-        # A generic music wish plays the FIRST configured station.
-        out = await router.handle_command("Kannst du für mich Musik spielen?")
-        assert out == "Hier kommt Energy Zürich." and len(played) == 1
-        # A NAMED song gets radio plus the honest sentence — never an invented promise.
-        out = await router.handle_command("Ich möchte, dass du mir ein Lied spielst und es sollte Komet heißen.")
-        assert "noch nicht" in out and len(played) == 2
-        # A named station is honored — the digit separates SRF 3 from SRF 1.
-        out = await router.handle_command("Spiel Radio SRF 3")
-        assert "SRF 3" in out and played[-1].endswith("srf3/mp3/128")
-        # "Musik aus" ends quietly through the interrupt path.
-        assert await router.handle_command("Musik aus") == ""
-        # No stations configured → the honest phrase, never a crash.
-        router.stations = {}
-        out = await router.handle_command("Spiel Musik")
-        assert out == router._phrases["no_stations"]
-        # Without a player wired, music requests fall through to the brain.
-        bare = BrainRouter({"lokal": FakeBrainOnly()}, "lokal")
-        assert await bare.handle_command("Spiel Musik") is None
-
-    asyncio.run(scenario())
-
-
-def test_station_name_alone_plays_despite_lost_first_word():
-    class FakeBrainOnly:
-        async def ask(self, text): return "h"
-        async def await_reply(self, handle, budget_s): return None
-        async def close(self): pass
-
-    async def scenario():
-        played = []
-        router = BrainRouter({"lokal": FakeBrainOnly()}, "lokal",
-                             phrases={"radio_on": "Hier kommt {station}."})
-        router.stations = {
-            "radio srf 3": ("Radio SRF 3", "https://example.test/srf3/mp3/128"),
-            "radio srf 1": ("Radio SRF 1", "https://example.test/srf1/mp3/128"),
-        }
-        async def player(url): played.append(url)
-        router.player = player
-        # The device loses the first word after wake: "Spiel Radio SRF 3" arrives mangled.
-        out = await router.handle_command("Die Radio-SRF 3.")
-        assert out == "Hier kommt Radio SRF 3." and played[-1].endswith("srf3/mp3/128")
-
-    asyncio.run(scenario())
-
-
-def test_named_song_resolves_through_music_assistant():
-    class FakeBrainOnly:
-        async def ask(self, text): return "h"
-        async def await_reply(self, handle, budget_s): return None
-        async def close(self): pass
-
-    class FakeMa:
-        def __init__(self, tracks, players):
-            self.tracks, self._players, self.played = tracks, players, []
-        async def search(self, query, **kw): return {"tracks": self.tracks}
-        async def players(self): return self._players
-        async def play(self, uri, player_id): self.played.append((uri, player_id))
-        async def close(self): pass
-
-    async def scenario():
-        router = BrainRouter({"lokal": FakeBrainOnly()}, "lokal",
-                             phrases={"playing_song": "Hier kommt {title} von {artist}.",
-                                      "song_hint": "Noch nicht — dafür {station}.",
-                                      "radio_on": "Hier kommt {station}."})
-        router.stations = {"energy zürich": ("Energy Zürich", "https://example.test/e.mp3")}
-        played_radio = []
-        async def player(url): played_radio.append(url)
-        router.player = player
-        # MA connected: the named song resolves and plays through THEIR tooling.
-        router.music = FakeMa([{"uri": "spotify://track/1", "name": "Komet",
-                                "artists": [{"name": "Udo Lindenberg"}]}],
-                              [{"player_id": "sat1", "available": True}])
-        out = await router.handle_command(
-            "Ich möchte, dass du mir ein Lied spielst und es sollte Komet heißen.")
-        assert out == "Hier kommt Komet von Udo Lindenberg."
-        assert router.music.played == [("spotify://track/1", "sat1")]
-        assert not played_radio
-        # MA finds nothing → the radio fallback with the honest sentence, never silence.
-        router.music = FakeMa([], [])
-        out = await router.handle_command(
-            "Kannst du mir bitte ein Lied spielen, es sollte Zebrastreifen heißen?")
-        assert "Noch nicht" in out and played_radio
-
-    asyncio.run(scenario())
diff --git a/clients/voice-gateway/tests/test_streaming.py b/clients/voice-gateway/tests/test_streaming.py
deleted file mode 100644
index e2d0d92d23..0000000000
--- a/clients/voice-gateway/tests/test_streaming.py
+++ /dev/null
@@ -1,73 +0,0 @@
-import asyncio
-
-import aiohttp
-import pytest
-
-from memex_voice_gateway.ollama import OllamaBrain
-from memex_voice_gateway.stt import wav_from_pcm
-from memex_voice_gateway.tts import TtsFileServer, split_wav, streaming_wav_header
-
-
-def test_split_wav_round_trip():
-    pcm = b"\x01\x02" * 800
-    got, rate = split_wav(wav_from_pcm(pcm, sample_rate=22050))
-    assert got == pcm and rate == 22050
-
-
-def test_streaming_header_shape():
-    header = streaming_wav_header(22050)
-    assert header[:4] == b"RIFF" and header[8:12] == b"WAVE" and len(header) == 44
-
-
-@pytest.mark.asyncio
-async def test_stream_endpoint_plays_chunks_as_they_arrive():
-    server = TtsFileServer("127.0.0.1", 8391)
-    await server.start()
-    try:
-        stream, url = server.open_stream(sample_rate=22050)
-
-        async def feed():
-            await stream.push(b"AA" * 100)
-            await asyncio.sleep(0.05)
-            await stream.push(b"BB" * 100)
-            await stream.close()
-
-        task = asyncio.create_task(feed())
-        async with aiohttp.ClientSession() as http:
-            async with http.get(url.replace("127.0.0.1:8391", "127.0.0.1:8391")) as response:
-                assert response.status == 200
-                body = await response.read()
-        await task
-        assert body[:4] == b"RIFF"
-        assert body[44:] == b"AA" * 100 + b"BB" * 100
-
-        # a stream is REPLAYABLE: the device's player sniffs the URL and re-requests it
-        # for playback, so the second fetch must serve the full buffered audio again
-        async with aiohttp.ClientSession() as http:
-            async with http.get(url) as response:
-                assert response.status == 200
-                assert (await response.read())[44:] == b"AA" * 100 + b"BB" * 100
-    finally:
-        await server.stop()
-
-
-def test_ollama_stream_text_drains_generated_pieces():
-    async def scenario():
-        brain = OllamaBrain("http://unused", "test-model")
-
-        async def fake_streaming(messages, handle):
-            queue = brain._chunks[handle]
-            for piece in ["Die Schweiz ", "hat 26 ", "Kantone."]:
-                await queue.put(piece)
-            await queue.put(None)
-            return "Die Schweiz hat 26 Kantone."
-
-        brain._chat_streaming = fake_streaming
-        handle = await brain.ask("Frage?")
-        stream = brain.stream_text(handle)
-        pieces = [piece async for piece in stream]
-        assert "".join(pieces) == "Die Schweiz hat 26 Kantone."
-        assert await brain.await_reply(handle, 1.0) == "Die Schweiz hat 26 Kantone."
-        await brain.close()
-
-    asyncio.run(scenario())
diff --git a/clients/voice-gateway/tests/test_stt.py b/clients/voice-gateway/tests/test_stt.py
deleted file mode 100644
index 6c73fe8dc5..0000000000
--- a/clients/voice-gateway/tests/test_stt.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import struct
-
-from memex_voice_gateway.stt import wav_from_pcm
-
-
-def test_wav_header_fields():
-    pcm = b"\x01\x02" * 1600  # 100 ms at 16 kHz mono s16le
-    wav = wav_from_pcm(pcm, sample_rate=16000)
-    assert wav[:4] == b"RIFF" and wav[8:12] == b"WAVE"
-    assert struct.unpack("<I", wav[4:8])[0] == 36 + len(pcm)
-    fmt = struct.unpack("<IHHIIHH", wav[16:36])
-    assert fmt == (16, 1, 1, 16000, 32000, 2, 16)
-    assert wav[36:40] == b"data"
-    assert struct.unpack("<I", wav[40:44])[0] == len(pcm)
-    assert wav[44:] == pcm
diff --git a/clients/voice-gateway/tests/test_threads.py b/clients/voice-gateway/tests/test_threads.py
deleted file mode 100644
index 01f2b7432b..0000000000
--- a/clients/voice-gateway/tests/test_threads.py
+++ /dev/null
@@ -1,93 +0,0 @@
-import json
-
-import pytest
-
-from memex_voice_gateway.threads import McpError, extract_reply, parse_tool_result
-
-
-def rpc_result(text: str) -> str:
-    return json.dumps({"jsonrpc": "2.0", "id": 9,
-                       "result": {"content": [{"type": "text", "text": text}]}})
-
-
-def test_parse_plain_json_result():
-    assert parse_tool_result(rpc_result("hello")) == "hello"
-
-
-def test_parse_sse_wrapped_result():
-    body = "event: message\ndata: " + rpc_result("hello") + "\n\n"
-    assert parse_tool_result(body) == "hello"
-
-
-def test_parse_rpc_error_raises():
-    body = json.dumps({"jsonrpc": "2.0", "id": 9, "error": {"code": -32000, "message": "nope"}})
-    with pytest.raises(McpError):
-        parse_tool_result(body)
-
-
-def test_parse_tool_level_error_raises():
-    body = json.dumps({"jsonrpc": "2.0", "id": 9,
-                       "result": {"isError": True,
-                                  "content": [{"type": "text", "text": "agent exploded"}]}})
-    with pytest.raises(McpError, match="agent exploded"):
-        parse_tool_result(body)
-
-
-# --- extract_reply: fixtures mirror live thread nodes observed on memex 2026-08-18 ---
-
-def thread_node(messages, pending=None, summary=None) -> str:
-    content = {"$type": "Thread", "messages": messages,
-               "pendingUserMessages": pending or {}}
-    if summary is not None:
-        content["summary"] = summary
-    return json.dumps({"$type": "MeshNode", "content": content})
-
-
-def test_new_message_ids_are_reported():
-    new_ids, failure = extract_reply(thread_node(["u1", "a1"]), known_ids={"u1"})
-    assert new_ids == ["a1"] and failure is None
-
-
-def test_dispatch_failure_surfaces_via_summary():
-    node = thread_node(["u1"], summary="Selected agent 'Voice' was not found")
-    new_ids, failure = extract_reply(node, known_ids={"u1"})
-    assert new_ids == [] and "not found" in failure
-
-
-def test_pending_round_suppresses_stale_summary():
-    pending = {"u2": {"role": "user", "text": "next question"}}
-    node = thread_node(["u1"], pending=pending, summary="an old digest")
-    _, failure = extract_reply(node, known_ids={"u1"})
-    assert failure is None
-
-
-def test_await_reply_skips_in_progress_placeholder():
-    """The platform materializes an assistant child MID-round ('Generating response...',
-    InProgress) whose text later becomes the real answer — it must be neither read aloud
-    nor marked seen."""
-    import asyncio
-
-    from memex_voice_gateway.threads import MemexThreads
-
-    async def scenario():
-        client = MemexThreads("http://unused", "t", "ns")
-        phase = {"n": 0}
-
-        async def fake_call(tool, arguments):
-            path = arguments.get("path", "")
-            if path == "@ns/_Thread/t1":
-                return json.dumps({"content": {"messages": ["m1"]}})
-            phase["n"] += 1
-            if phase["n"] == 1:
-                return json.dumps({"content": {"role": "assistant",
-                                               "text": "Generating response...",
-                                               "status": "InProgress"}})
-            return json.dumps({"content": {"role": "assistant",
-                                           "text": "Es sind 26 Kantone.",
-                                           "status": "Completed"}})
-
-        client.call = fake_call
-        reply = await client.await_reply("ns/_Thread/t1", budget_s=5, poll_interval_s=0.01)
-        assert reply == "Es sind 26 Kantone."
-
-    asyncio.run(scenario())
diff --git a/clients/voice-gateway/tests/test_vad.py b/clients/voice-gateway/tests/test_vad.py
deleted file mode 100644
index 076f997930..0000000000
--- a/clients/voice-gateway/tests/test_vad.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import math
-import struct
-
-from memex_voice_gateway.vad import Endpointer, rms
-
-
-def tone(ms: int, amplitude: int = 8000, rate: int = 16000) -> bytes:
-    n = rate * ms // 1000
-    return struct.pack(f"<{n}h", *(int(amplitude * math.sin(i / 5)) for i in range(n)))
-
-
-def silence(ms: int, rate: int = 16000) -> bytes:
-    return b"\x00\x00" * (rate * ms // 1000)
-
-
-def feed_chunks(endpointer: Endpointer, audio: bytes, chunk_ms: int = 20) -> bool:
-    step = 16000 * 2 * chunk_ms // 1000
-    done = False
-    for offset in range(0, len(audio), step):
-        done = endpointer.feed(audio[offset:offset + step])
-        if done:
-            break
-    return done
-
-
-def test_rms_of_silence_is_zero():
-    assert rms(silence(20)) == 0.0
-    assert rms(b"") == 0.0
-
-
-def test_speech_then_silence_ends_the_utterance():
-    endpointer = Endpointer(silence_ms=400)
-    audio = silence(200) + tone(800) + silence(1000)
-    assert feed_chunks(endpointer, audio) is True
-    assert len(endpointer.audio) > 0
-
-
-def test_pure_silence_only_ends_at_max_duration():
-    endpointer = Endpointer(silence_ms=400, max_utterance_s=1.0)
-    assert feed_chunks(endpointer, silence(900)) is False
-    assert feed_chunks(endpointer, silence(300)) is True  # crosses max_utterance_s
-
-
-def test_too_short_speech_does_not_end_early():
-    endpointer = Endpointer(silence_ms=300, min_utterance_s=0.5)
-    # 100 ms of speech is below the minimum, so trailing silence must NOT end the round yet.
-    assert feed_chunks(endpointer, silence(100) + tone(100) + silence(500)) is False
diff --git a/clients/voice-gateway/wakeword/README.md b/clients/voice-gateway/wakeword/README.md
deleted file mode 100644
index 14b7d09f41..0000000000
--- a/clients/voice-gateway/wakeword/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# "Hey Memex" — the custom wake word
-
-A microWakeWord model (61 KB streaming tflite) trained 2026-08-19 on 2000 synthetic
-voicings ("hey memex" + "hey meemex", piper-sample-generator) with the upstream
-basic-training recipe, updated for current dependency reality (see the scripts: parquet
-AudioSet, direct 16 kHz RIRs, ffmpeg FMA conversion, setuptools<81, tensorboard,
-audiomentations>=0.43).
-
-ROC (streaming, quantized): cutoff **0.89** ships in `hey_memex.json` — frr 11.5%,
-0.19 false accepts/hour; 0.99 = zero faph at frr 21%; 0.80 = frr 8% at 0.375 faph.
-Tune `probability_cutoff` in the manifest without retraining.
-
-Deploy: add to the Satellite1-ESPHome config's `micro_wake_word.models`:
-`- model: hey_memex.json` + `id: hey_memex` (files beside the main yaml; local paths must
-not contain `../`), build with ESPHome ≥ 2026.7.0, `esphome run … --device <ip>` (factory
-OTA is passwordless on the LAN). The gateway activates it via `WAKE_WORD=hey_memex`.
-
-⚠️ Trained with mixed-license augmentation data (upstream's note): NON-COMMERCIAL
-personal use.
diff --git a/clients/voice-gateway/wakeword/hey_memex.json b/clients/voice-gateway/wakeword/hey_memex.json
deleted file mode 100644
index 2976d0987a..0000000000
--- a/clients/voice-gateway/wakeword/hey_memex.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-  "type": "micro",
-  "wake_word": "Hey Memex",
-  "author": "Roland Buergi (trained with microWakeWord)",
-  "website": "https://meshweaver.cloud",
-  "model": "hey_memex.tflite",
-  "trained_languages": [
-    "en"
-  ],
-  "version": 2,
-  "micro": {
-    "probability_cutoff": 0.89,
-    "feature_step_size": 10,
-    "sliding_window_size": 5,
-    "tensor_arena_size": 30000,
-    "minimum_esphome_version": "2024.7.0"
-  }
-}
\ No newline at end of file
diff --git a/clients/voice-gateway/wakeword/hey_memex.tflite b/clients/voice-gateway/wakeword/hey_memex.tflite
deleted file mode 100644
index dd132bccea0b7c23b214d19617fbcd9eea70abeb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 62304
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

diff --git a/clients/voice-gateway/wakeword/phase2_data.py b/clients/voice-gateway/wakeword/phase2_data.py
deleted file mode 100644
index 5142524084..0000000000
--- a/clients/voice-gateway/wakeword/phase2_data.py
+++ /dev/null
@@ -1,135 +0,0 @@
-"""Phase 2a — augmentation data + features, faithfully following microWakeWord's
-basic_training_notebook (cells 4–9). Run from ~/models/wakeword with the venv.
-
-Upstream's own note: the downloaded augmentation data mixes licenses — a model trained
-with it is for NON-COMMERCIAL personal use. Fits the satellite's posture.
-"""
-import os
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-os.chdir(os.path.expanduser("~/models/wakeword"))
-
-def stage(name):
-    print(f"\n===== {name} =====", flush=True)
-
-stage("merge samples into generated_samples")
-merged = Path("generated_samples")
-merged.mkdir(exist_ok=True)
-for src, prefix in [("samples", "hm"), ("samples-alt", "alt")]:
-    for f in Path(src).glob("*.wav"):
-        target = merged / f"{prefix}_{f.name}"
-        if not target.exists():
-            shutil.copy(f, target)
-print("merged:", len(list(merged.glob('*.wav'))))
-
-import datasets
-import numpy as np
-import scipy.io.wavfile
-from tqdm import tqdm
-
-stage("MIT RIRs (direct 16khz files — the datasets-API row shape changed upstream)")
-if not os.path.exists("mit_rirs") or not os.listdir("mit_rirs"):
-    os.makedirs("mit_rirs", exist_ok=True)
-    import json as _json, urllib.request
-    tree = _json.load(urllib.request.urlopen(
-        "https://huggingface.co/api/datasets/davidscripka/MIT_environmental_impulse_responses/tree/main/16khz"))
-    for entry in tqdm(tree):
-        name = entry["path"].split("/")[-1]
-        target = os.path.join("mit_rirs", name)
-        if not os.path.exists(target):
-            urllib.request.urlretrieve(
-                "https://huggingface.co/datasets/davidscripka/MIT_environmental_impulse_responses/resolve/main/" + entry["path"],
-                target)
-
-stage("AudioSet slice (parquet shard — upstream retired the tar layout)")
-if not os.path.exists("audioset/bal_train09.parquet"):
-    os.makedirs("audioset", exist_ok=True)
-    subprocess.run(["curl", "-fSL", "-o", "audioset/bal_train09.parquet.tmp",
-                    "https://huggingface.co/datasets/agkphysics/AudioSet/resolve/main/data/bal_train/09.parquet"],
-                   check=True)
-    os.rename("audioset/bal_train09.parquet.tmp", "audioset/bal_train09.parquet")
-if not os.path.exists("audioset_16k"):
-    os.mkdir("audioset_16k")
-    import io
-    import pyarrow.parquet as pq
-    import soundfile as sf
-    from scipy.signal import resample_poly
-    table = pq.read_table("audioset/bal_train09.parquet", columns=["audio"])
-    for i, row in enumerate(tqdm(table.column("audio").to_pylist())):
-        try:
-            data, rate = sf.read(io.BytesIO(row["bytes"]))
-            if data.ndim > 1:
-                data = data.mean(axis=1)
-            if rate != 16000:
-                data = resample_poly(data, 16000, rate)
-            scipy.io.wavfile.write(os.path.join("audioset_16k", f"as_{i}.wav"), 16000,
-                                   (np.clip(data, -1, 1) * 32767).astype(np.int16))
-        except Exception as e:
-            print("skip", i, e)
-
-stage("FMA xsmall")
-if not os.path.exists("fma"):
-    os.mkdir("fma")
-    subprocess.run(["curl", "-fSL", "-o", "fma/fma_xs.zip",
-                    "https://huggingface.co/datasets/mchl914/fma_xsmall/resolve/main/fma_xs.zip"],
-                   check=True)
-    subprocess.run(["unzip", "-q", "fma_xs.zip"], cwd="fma", check=True)
-if not os.path.exists("fma_16k") or not os.listdir("fma_16k"):
-    os.makedirs("fma_16k", exist_ok=True)
-    mp3s = list(Path("fma/fma_small").glob("**/*.mp3"))
-    for f in tqdm(mp3s):
-        target = os.path.join("fma_16k", f.stem + ".wav")
-        if not os.path.exists(target):
-            r = subprocess.run(["ffmpeg", "-loglevel", "error", "-y", "-i", str(f),
-                                "-ar", "16000", "-ac", "1", target])
-            if r.returncode != 0 and os.path.exists(target):
-                os.unlink(target)   # never leave a truncated wav for the augmenter
-
-stage("negative feature sets")
-if not os.path.exists("negative_datasets"):
-    os.mkdir("negative_datasets")
-    root = "https://huggingface.co/datasets/kahrendt/microwakeword/resolve/main/"
-    for fname in ["dinner_party.zip", "dinner_party_eval.zip", "no_speech.zip", "speech.zip"]:
-        subprocess.run(["curl", "-fSL", "-o", f"negative_datasets/{fname}", root + fname], check=True)
-        subprocess.run(["unzip", "-q", f"negative_datasets/{fname}", "-d", "negative_datasets"], check=True)
-
-stage("augment + spectrogram features")
-from microwakeword.audio.augmentation import Augmentation
-from microwakeword.audio.clips import Clips
-from microwakeword.audio.spectrograms import SpectrogramGeneration
-from mmap_ninja.ragged import RaggedMmap
-
-clips = Clips(input_directory="generated_samples", file_pattern="*.wav",
-              max_clip_duration_s=None, remove_silence=False,
-              random_split_seed=10, split_count=0.1)
-augmenter = Augmentation(augmentation_duration_s=3.2,
-                         augmentation_probabilities={
-                             "SevenBandParametricEQ": 0.1, "TanhDistortion": 0.1,
-                             "PitchShift": 0.1, "BandStopFilter": 0.1,
-                             "AddColorNoise": 0.1, "AddBackgroundNoise": 0.75,
-                             "Gain": 1.0, "RIR": 0.5},
-                         impulse_paths=["mit_rirs"],
-                         background_paths=["fma_16k", "audioset_16k"],
-                         background_min_snr_db=-5, background_max_snr_db=10,
-                         min_jitter_s=0.195, max_jitter_s=0.205)
-
-os.makedirs("generated_augmented_features", exist_ok=True)
-for split in ["training", "validation", "testing"]:
-    out_dir = os.path.join("generated_augmented_features", split)
-    os.makedirs(out_dir, exist_ok=True)
-    split_name, repetition = "train", 2
-    spectrograms = SpectrogramGeneration(clips=clips, augmenter=augmenter, slide_frames=10, step_ms=10)
-    if split == "validation":
-        split_name, repetition = "validation", 1
-    elif split == "testing":
-        split_name, repetition = "test", 1
-        spectrograms = SpectrogramGeneration(clips=clips, augmenter=augmenter, slide_frames=1, step_ms=10)
-    RaggedMmap.from_generator(
-        out_dir=os.path.join(out_dir, "wakeword_mmap"),
-        sample_generator=spectrograms.spectrogram_generator(split=split_name, repeat=repetition),
-        batch_size=100, verbose=True)
-
-print("\n===== PHASE 2a DONE =====", flush=True)
diff --git a/clients/voice-gateway/wakeword/phase2_train.sh b/clients/voice-gateway/wakeword/phase2_train.sh
deleted file mode 100755
index 1cfac60961..0000000000
--- a/clients/voice-gateway/wakeword/phase2_train.sh
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/bin/sh
-# Phase 2 chain: data+features (2a), then training config + 10k-step training + quantized
-# streaming tflite export (2b) — the notebook's cells 9–10 verbatim.
-set -e
-cd "$HOME/models/wakeword"
-V=./venv/bin
-
-echo "===== PHASE 2a: data + features ====="
-$V/python phase2_data.py
-
-echo "===== PHASE 2b: training config ====="
-$V/python - <<'EOF'
-import yaml
-config = {
-    "window_step_ms": 10,
-    "train_dir": "trained_models/wakeword",
-    "features": [
-        {"features_dir": "generated_augmented_features", "sampling_weight": 2.0,
-         "penalty_weight": 1.0, "truth": True, "truncation_strategy": "truncate_start", "type": "mmap"},
-        {"features_dir": "negative_datasets/speech", "sampling_weight": 10.0,
-         "penalty_weight": 1.0, "truth": False, "truncation_strategy": "random", "type": "mmap"},
-        {"features_dir": "negative_datasets/dinner_party", "sampling_weight": 10.0,
-         "penalty_weight": 1.0, "truth": False, "truncation_strategy": "random", "type": "mmap"},
-        {"features_dir": "negative_datasets/no_speech", "sampling_weight": 5.0,
-         "penalty_weight": 1.0, "truth": False, "truncation_strategy": "random", "type": "mmap"},
-        {"features_dir": "negative_datasets/dinner_party_eval", "sampling_weight": 0.0,
-         "penalty_weight": 1.0, "truth": False, "truncation_strategy": "split", "type": "mmap"},
-    ],
-    "training_steps": [10000],
-    "positive_class_weight": [1],
-    "negative_class_weight": [20],
-    "learning_rates": [0.001],
-    "batch_size": 128,
-    "time_mask_max_size": [0], "time_mask_count": [0],
-    "freq_mask_max_size": [0], "freq_mask_count": [0],
-    "eval_step_interval": 500,
-    "clip_duration_ms": 1500,
-    "target_minimization": 0.9,
-    "minimization_metric": None,
-    "maximization_metric": "average_viable_recall",
-}
-yaml.dump(config, open("training_parameters.yaml", "w"))
-print("training_parameters.yaml written")
-EOF
-
-echo "===== PHASE 2b: train (10k steps) ====="
-$V/python -m microwakeword.model_train_eval \
-  --training_config=training_parameters.yaml \
-  --train 1 --restore_checkpoint 1 \
-  --test_tf_nonstreaming 0 --test_tflite_nonstreaming 0 \
-  --test_tflite_nonstreaming_quantized 0 --test_tflite_streaming 0 \
-  --test_tflite_streaming_quantized 1 \
-  --use_weights best_weights \
-  mixednet \
-  --pointwise_filters "64,64,64,64" \
-  --repeat_in_block "1, 1, 1, 1" \
-  --mixconv_kernel_sizes '[5], [7,11], [9,15], [23]' \
-  --residual_connection "0,0,0,0" \
-  --first_conv_filters 32 --first_conv_kernel_size 5 --stride 3
-
-echo "===== PHASE 2 COMPLETE ====="
-ls -lh trained_models/wakeword/tflite_stream_state_internal_quant/ 2>/dev/null
diff --git a/clients/voice-gateway/wakeword/setup-hey-memex.sh b/clients/voice-gateway/wakeword/setup-hey-memex.sh
deleted file mode 100755
index b30d99ddaa..0000000000
--- a/clients/voice-gateway/wakeword/setup-hey-memex.sh
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/bin/sh
-# Phase 1 of the "Hey Memex" wake word: training environment + synthetic sample generation.
-# microWakeWord (the satellite's on-device engine) + piper-sample-generator (synthetic
-# voicings). Output: ~/models/wakeword/samples/ ready for feature extraction + training.
-set -e
-W="$HOME/models/wakeword"
-mkdir -p "$W" && cd "$W"
-
-echo "=== clone"
-[ -d microWakeWord ] || git clone --depth 1 https://github.com/kahrendt/microWakeWord.git
-[ -d piper-sample-generator ] || git clone --depth 1 https://github.com/rhasspy/piper-sample-generator.git
-
-echo "=== venv (3.12) + deps"
-[ -d venv ] || python3.12 -m venv venv
-./venv/bin/pip -q install --upgrade pip
-./venv/bin/pip -q install torch torchaudio numpy
-./venv/bin/pip -q install -e ./microWakeWord || echo "microWakeWord editable install failed — will pip its requirements at training time"
-
-echo "=== sample generation model"
-cd piper-sample-generator
-[ -f models/en_US-libritts_r-medium.pt ] || { mkdir -p models; curl -fSL -o models/en_US-libritts_r-medium.pt \
-  "https://github.com/rhasspy/piper-sample-generator/releases/download/v2.0.0/en_US-libritts_r-medium.pt"; }
-
-echo "=== generate 'hey memex' samples (multiple pronunciations, many voices)"
-mkdir -p "$W/samples"
-../venv/bin/python generate_samples.py "hey memex" \
-  --max-samples 1500 --batch-size 50 --output-dir "$W/samples" 2>&1 | tail -3
-# A second phonetic spelling catches the 'MEE-mex' reading:
-../venv/bin/python generate_samples.py "hey meemex" \
-  --max-samples 500 --batch-size 50 --output-dir "$W/samples-alt" 2>&1 | tail -3 || true
-
-echo "=== DONE phase 1"
-ls "$W/samples" | wc -l
diff --git a/src/MeshWeaver.Documentation/Data/Architecture/CarvingProjectsOutOfCore.md b/src/MeshWeaver.Documentation/Data/Architecture/CarvingProjectsOutOfCore.md
index 642f445dff..79c8b1e6fb 100644
--- a/src/MeshWeaver.Documentation/Data/Architecture/CarvingProjectsOutOfCore.md
+++ b/src/MeshWeaver.Documentation/Data/Architecture/CarvingProjectsOutOfCore.md
@@ -104,8 +104,8 @@ So the keystone was narrower than it looked: it gated `GitSync`, and it never ga
 ### What the move carried with it, and what it left unguarded
 
 - 🚨 **The `InternalsVisibleTo` grants stay in core.** `MeshWeaver.Graph`, `.Hosting`,
-  `.Hosting.AspNetCore`, `.Compiler`, `.Mesh.Operations`, `.PluginCatalog` and `.Testcontainers`
-  name `Memex.Portal.Shared` / `Memex.Portal.Shared.Test`, which are now assemblies of ANOTHER
+  `.Hosting.AspNetCore`, `.Compiler`, `.Mesh.Operations` and `.PluginCatalog` (and `.Testcontainers`
+  until it followed the suite to plugins, below) name `Memex.Portal.Shared` / `Memex.Portal.Shared.Test`, which are now assemblies of ANOTHER
   repository. That is the #2689 shape — a refactor of one of those internals can red the plugins
   trunk with no local signal — and what catches it is the required
   `Dependent suites (MeshWeaver.Plugins)` verdict, which selects the moved suite by compiled reach.
@@ -172,10 +172,36 @@ delivery event, not a refactor, and it is why these do not get done casually or
 | `PluginCatalog` | 21 245 | **yes** | PluginTester, ComboAssembler/Verifier | **stays** — it *is* the plugin system |
 | `Documentation` | 1 670 | no | the doc gate; settled decision | **stays** |
 | `Mesh.Operations` | 4 726 | **yes** | PluginTester (Portal.Shared and LocalMesh consume it from plugins) | **stays** |
+| `Testcontainers` | 385 | no | nothing: its two consumers (`Memex.Portal.Shared.Test`, `MeshWeaver.Testcontainers.Test`) were already in plugins | moved out — free |
+| `Hosting.AspNetCore` | 3 970 | no | `memex/aspire/Memex.Portal.ServiceDefaults` (leaving with #7297); **the satellite MeshWeaver.SocialMedia**, whose compiled module `MeshWeaver.Social` derives from `MeshEndpointProviderAttribute` and compiles against core SOURCE | **stays** for now — a move makes a satellite depend on plugins (see below) |
+| `Markdown.Export.Contract` | 355 | no | `Hosting.AspNetCore` (`PortalApplication`) | stays while `Hosting.AspNetCore` does |
 
 Everything not listed is kernel: messaging, data, layout, the mesh contract, hosting, the compiler
 and NuGet resolution, packaging.
 
+### Outside the content surface is not the same as free
+
+The content-surface test answers "does a move flip the framework identity". It does not answer "who
+else compiles against this from source". `Hosting.AspNetCore` is outside the surface, and no project
+in core's `src/`, `test/` or `tools/` references it, so it looked free. Two consumers say otherwise:
+
+- `memex/aspire/Memex.Portal.ServiceDefaults` references it. That project is itself leaving core
+  (Systemorph/MeshWeaver#7297, Plugins#4333), so this pin goes away on its own.
+- **A satellite references it.** MeshWeaver.SocialMedia's compiled module `MeshWeaver.Social` declares
+  its HTTP endpoints through `MeshEndpointProviderAttribute`, the endpoint-contribution hook (design
+  #1655), and compiles it from `$(MeshWeaverRoot)/src/MeshWeaver.Hosting.AspNetCore`. Satellites
+  depend on the platform and on nothing else (see
+  [Repository Dependency Direction](../RepositoryDependencyDirection)); none checks out
+  MeshWeaver.Plugins. Moving the project would leave that module with no source to compile against.
+
+So `Hosting.AspNetCore` stays until the hook is split from the portal infrastructure in `Portal/`:
+the hook (`MeshEndpointProviderAttribute`, `ModuleEndpointDataSource`, the endpoint and static-asset
+extensions) is a platform extension point, and `Portal/` is host code. That split changes which
+assembly declares public types, so it needs type forwarders and is a design change, not a move.
+`Markdown.Export.Contract` is pinned by `Hosting.AspNetCore` alone (`PortalApplication`), so it waits
+with it. 🚨 **Before calling any move free, grep the satellites' `.csproj` files for
+`$(MeshWeaverRoot)/src/<Project>`**, not only core's.
+
 ### The `ProjectReference` graph lies about all of them
 
 🚨 Four of the references that appear to pin these projects turned out to carry **no code
@@ -352,6 +378,19 @@ not cover MeshWeaver.Plugins' `publish-aspire-package.yml`. The package owner ha
 policy, and set `vars.NUGET_TRUSTED_USER` there, before the next Aspire package release. Until then
 that lane's `preflight` is red by name.
 
+## The `clients/` tree
+
+Each client goes where its consumers are, like the deployment material above.
+
+| Piece | Went to | Why there |
+|---|---|---|
+| `clients/voice-gateway` | MeshWeaver.Plugins `clients/voice-gateway` | A standalone Python container that talks to a memex over HTTP and MCP. Nothing in core builds or reads it, and core ran no job for it. It now sits beside the other clients and the Speech module, with its own `Voice gateway` workflow running its 44 pytest cases. |
+| `clients/python` (the `meshweaver` SDK) | **stays** | `deploy/python-gate` and `deploy/pandas-gate`, both core-built images, `COPY` it, and it generates from core's canonical `mesh.proto`. Moving it would make a core image depend on another repository. `clients.yml` stays with it. |
+| `clients/README.md` | stays, rewritten | It describes what is left and where the rest went. |
+
+Nothing here belongs in MeshWeaver.Deploy: neither piece puts a sealed set anywhere or watches where it
+runs.
+
 ## The product demo samples
 
 ACME, FutuRe, Northwind and PensionFund were product demos sitting in the framework's
diff --git a/src/MeshWeaver.Documentation/Data/Architecture/DockerHubInCi.md b/src/MeshWeaver.Documentation/Data/Architecture/DockerHubInCi.md
index c6c45013fd..0c5ecdd55d 100644
--- a/src/MeshWeaver.Documentation/Data/Architecture/DockerHubInCi.md
+++ b/src/MeshWeaver.Documentation/Data/Architecture/DockerHubInCi.md
@@ -76,7 +76,7 @@ on `main` and on the schedule, once for each new digest.
 ## What this does not cover
 
 - **`FROM` lines of images core builds** (`deploy/node-gate`, `deploy/python-gate`,
-  `deploy/s1-extract`, `deploy/whisper`, `deploy/ocr`, `deploy/ollama`, `clients/voice-gateway`). BuildKit pulls those base
+  `deploy/s1-extract`, `deploy/whisper`, `deploy/ocr`, `deploy/ollama`; `clients/voice-gateway` has since moved to MeshWeaver.Plugins). BuildKit pulls those base
   images from Docker Hub. The workflows that build them are path-filtered and run rarely, and no
   measured failure was there. Moving their bases is a separate change, because it
   changes the production image's provenance, not only CI's.
diff --git a/src/MeshWeaver.Documentation/Data/Architecture/DocsFollowTheFunctionality.md b/src/MeshWeaver.Documentation/Data/Architecture/DocsFollowTheFunctionality.md
index b62a94d278..52087fdad4 100644
--- a/src/MeshWeaver.Documentation/Data/Architecture/DocsFollowTheFunctionality.md
+++ b/src/MeshWeaver.Documentation/Data/Architecture/DocsFollowTheFunctionality.md
@@ -286,7 +286,8 @@ compiled by two independent lanes, and not covered by `samples-gate.allow`.
 
 **`clients/voice-gateway` — 35 files with no CI job at all**, excluded from CD change detection, and
 the workflow says so in a comment. A Home Assistant / Ollama voice satellite sitting in the framework
-repo, unbuilt and untested.
+repo, unbuilt and untested. **Done:** it moved to MeshWeaver.Plugins `clients/voice-gateway`, which
+runs its 44 pytest cases in a `Voice gateway` workflow of its own.
 
 ## The plan, ranked by value over cost
 
@@ -297,7 +298,7 @@ repo, unbuilt and untested.
 | 3 | **Build `ModuleDocProvider`** in `MeshWeaver.Hosting` | — | enables 2, 4 | depth, page assets, and porting the doc gate to modules |
 | 4 | **The ~20 module-owned `Architecture` pages** | ~20 | **yes** | per-page; 838 inbound links, so redirects are mandatory |
 | 5 | **`samples/` → plugins**, Northwind first | 953 | **yes** — closes the two-repo split | 13 test projects; one PR gate stage must move with it |
-| 6 | **`clients/voice-gateway`** | 35 | yes | none measurable — nothing builds it |
+| 6 | **`clients/voice-gateway`** — done, now in MeshWeaver.Plugins | 35 | yes | none measurable — nothing builds it |
 
 **Stays in core, and the reason is the rule, not inertia:** `Architecture`'s reactive, storage,
 security, node-type, plugin-system and release pages; all of `DataMesh` bar two; all of `GUI` bar
diff --git a/src/MeshWeaver.Documentation/Data/Architecture/FirstRunSetup.md b/src/MeshWeaver.Documentation/Data/Architecture/FirstRunSetup.md
index 77403ec483..2cf778f97b 100644
--- a/src/MeshWeaver.Documentation/Data/Architecture/FirstRunSetup.md
+++ b/src/MeshWeaver.Documentation/Data/Architecture/FirstRunSetup.md
@@ -235,7 +235,7 @@ should be checked the same way once, at ramp-up.
 
 ### A deployment path nobody listed: the test container (#6037)
 
-`MeshWeaver.Testcontainers` starts the portal image as a test substrate, and it is a deployment
+`MeshWeaver.Testcontainers` (MeshWeaver.Plugins `src/`) starts the portal image as a test substrate, and it is a deployment
 path too — one that stated `ConnectionStrings:memex` and **not** `Graph:Storage:Type`. Every
 container it ever started therefore served the wizard. Nothing noticed, because its wait was
 `200` on `/healthz`, and the wizard answers **every** probe path (`/healthz`, `/health`, `/alive`,
diff --git a/src/MeshWeaver.Documentation/Data/Architecture/InstanceIdentityAndSetup.md b/src/MeshWeaver.Documentation/Data/Architecture/InstanceIdentityAndSetup.md
index 713828b683..091c50fbd5 100644
--- a/src/MeshWeaver.Documentation/Data/Architecture/InstanceIdentityAndSetup.md
+++ b/src/MeshWeaver.Documentation/Data/Architecture/InstanceIdentityAndSetup.md
@@ -39,7 +39,7 @@ The survey behind this design (three read-only sweeps of core, `MeshWeaver.Plugi
 | A setup wizard | `Hosting/FleetConsole/Source/SetupDialog.cs` — six steps (Identity · Main database · Main storage · Boot modules · Packages & repos · Review), files a `Hosting/InstanceRequest` | Provisions *another* instance in a fleet, not the one you are on; its module step is a free list with no plan |
 | Environment changes | `Hosting/Deployment` (the full instance shape, ~60 fields, all `[Description]`+`[Translation]`), `HelmValues.Render` (a values file that `hosting-deploy` **refuses unless** it carries `# GENERATED from the Hosting/Deployment record`), `Hosting/InstanceAction` verbs run by the in-cluster `hosting-operator` Job | `Hosting/Deployment/*` is **empty** on every mesh we run. The plugin registry instance's configuration is hand-maintained in Key Vault (a `helm-values-<instance>` secret) and a Memex-repo overlay, applied by a hand-dispatched workflow (Systemorph/Memex#152) |
 | The app | `Hosting` is a Store package with `app: true`, `entryPoint: Hosting/Console` — it has a home tile | `tier: enterprise` — the one package every instance is supposed to run cannot be installed by a free instance |
-| E2E | Plugins `e2e/{instance-lifecycle,instance-request,setup-dialog}.spec.ts` (dry-run, `.invalid` DNS); core `MeshWeaver.Testcontainers` (#2790, a disposable memex with `WithPostgres`); `memex-local instance up` (mint → migrate → deploy → register → install) | No suite joins install → wizard → registered instance → plan-limited modules → promotion |
+| E2E | Plugins `e2e/{instance-lifecycle,instance-request,setup-dialog}.spec.ts` (dry-run, `.invalid` DNS); Plugins `MeshWeaver.Testcontainers` (#2790, moved from core; a disposable memex with `WithPostgres`); `memex-local instance up` (mint → migrate → deploy → register → install) | No suite joins install → wizard → registered instance → plan-limited modules → promotion |
 
 ## The design
 
diff --git a/src/MeshWeaver.Documentation/Data/Architecture/VoiceModelDistribution.md b/src/MeshWeaver.Documentation/Data/Architecture/VoiceModelDistribution.md
index 6483786aa4..a48f105d8e 100644
--- a/src/MeshWeaver.Documentation/Data/Architecture/VoiceModelDistribution.md
+++ b/src/MeshWeaver.Documentation/Data/Architecture/VoiceModelDistribution.md
@@ -39,7 +39,7 @@ from. Measured from the model card and the HuggingFace API on 2026-09-10 — `ca
 Attribution-NonCommercial 4.0 license."*
 
 **This was already known in one corner of the repo, and the pointer was dangling.**
-`clients/voice-gateway/README.md` has carried a "Speech model license" section all along — *"**CC BY-NC 4.0
+`clients/voice-gateway/README.md` (now in MeshWeaver.Plugins) has carried a "Speech model license" section all along — *"**CC BY-NC 4.0
 — non-commercial use only**. A personal home assistant is non-commercial use; for anything commercial, point
 the whisper container at a permissively licensed model (see `deploy/whisper/README.md`)"* — but
 `deploy/whisper/README.md`, the page it sends you to, said nothing about a licence at all. So the constraint
@@ -191,7 +191,7 @@ Anything that names this asset is a consumer, and a move must visit all of them
 | `deploy/whisper/helm/templates/deployment.yaml` | nothing at run time; the model is in the image |
 | `deploy/whisper/helm/values.yaml` | an `image.tag` whose image was built **with** a model |
 | `Systemorph/Memex` → `deployments/aks/<env>/whisper/helm/` | a **verbatim vendored copy** of the chart above — it drifts silently and must be mirrored |
-| `clients/voice-gateway/run-local.sh` + README | `gh release download` into `$WHISPER_MODEL` |
+| MeshWeaver.Plugins `clients/voice-gateway/run-local.sh` + README | `gh release download` into `$WHISPER_MODEL` |
 | `.gitignore` | keeps `deploy/whisper/models/` untracked (GitHub rejects any blob over 100 MB) |
 | MAUI `VoiceModelCatalog` | its own catalog URL — see [On-device voice](/Doc/Architecture/OnDeviceVoice) |
 
diff --git a/src/MeshWeaver.Testcontainers/MemexContainer.cs b/src/MeshWeaver.Testcontainers/MemexContainer.cs
deleted file mode 100644
index ceaa825af1..0000000000
--- a/src/MeshWeaver.Testcontainers/MemexContainer.cs
+++ /dev/null
@@ -1,202 +0,0 @@
-using Docker.DotNet.Models;
-using DotNet.Testcontainers.Builders;
-using DotNet.Testcontainers.Configurations;
-using DotNet.Testcontainers.Containers;
-
-namespace MeshWeaver.Testcontainers;
-
-/// <summary>
-/// A disposable memex — the portal image the platform BUILD produced, started as a test substrate
-/// the way <c>Testcontainers.PostgreSql</c> starts a real Postgres (maintainer, 2026-08-30:
-/// "clean test container package for memex … similar to pg"). The test is a client: it reaches
-/// the instance over HTTP/MCP at <see cref="BaseAddress"/>, and the platform under test is
-/// exactly the image the pipeline promoted — no core source checkout, no in-process mesh, no
-/// <c>MeshWeaver.Fixture</c>.
-///
-/// <para><b>What the image needs, and what the builder sets.</b> The portal image runs
-/// <c>Memex.Portal.Distributed</c> (Orleans + Postgres). A throwaway instance is single-node
-/// (<c>Features:Orleans:Clustering=Localhost</c>), Azure-free (<c>Deployment:Backend=Filesystem</c>
-/// with <c>Deployment:DataRoot</c> under <c>/tmp</c> — the image runs as a non-root user, and a
-/// <c>/data</c> root kills the host at its first <c>CreateDirectory</c>), has dev login ON (the
-/// host forces it OFF unless the value is literally <c>true</c>) and needs ONE Postgres for its
-/// data — which is why <see cref="MemexBuilder.WithPostgres(string)"/> is required. It states BOTH
-/// halves of the storage decision: <c>ConnectionStrings:memex</c> and
-/// <c>Graph:Storage:Type=PostgreSql</c>. The image deliberately bakes no storage type, so an
-/// instance that is not TOLD one serves the first-run setup wizard instead of a mesh
-/// (MeshWeaver#6037). The memex reaches Postgres INSIDE the Docker network, so hand it the
-/// alias-based connection string of a Postgres container on the same network, never a host-mapped
-/// port — and migrate that database first (the <c>memex-migration</c> image of the same build):
-/// the portal's <c>DbVersionGate</c> refuses to start over a schema it does not find.</para>
-///
-/// <para><b>Started means the MESH started.</b> The wait is <see cref="MemexReadiness"/>: the
-/// startup census on <c>/health</c> of a composed host, never a probe path's flat <c>200 ok</c>,
-/// which the setup wizard answers too. A container serving the wizard, or one that exits before
-/// its mesh starts, fails <c>StartAsync</c> at once with the reason.</para>
-///
-/// <para><b>The container's log is the test's log.</b> stdout/stderr are redirected to the test
-/// output by default, so a failing test shows the portal's own lines beside it (maintainer:
-/// "pls see we log out from container to github logging").</para>
-/// </summary>
-public sealed class MemexContainer(MemexConfiguration configuration) : DockerContainer(configuration)
-{
-    /// <summary>The instance's HTTP root as seen from the test host.</summary>
-    public Uri BaseAddress =>
-        new UriBuilder(Uri.UriSchemeHttp, Hostname, GetMappedPublicPort(MemexBuilder.HttpPort)).Uri;
-
-    /// <summary>The MCP endpoint (<c>/mcp</c>).</summary>
-    public Uri McpEndpoint => new(BaseAddress, "/mcp");
-
-    /// <summary>The startup census the wait strategy reads (<c>/health</c>).</summary>
-    public Uri HealthEndpoint => new(BaseAddress, MemexBuilder.HealthPath);
-}
-
-/// <summary>The memex-specific part of the container configuration.</summary>
-public sealed class MemexConfiguration : ContainerConfiguration
-{
-    /// <summary>A fresh configuration with the memex-specific values.</summary>
-    public MemexConfiguration(string? memexConnectionString = null)
-    {
-        MemexConnectionString = memexConnectionString;
-    }
-
-    /// <summary>Clones a resource configuration (Testcontainers' builder contract).</summary>
-    public MemexConfiguration(IResourceConfiguration<CreateContainerParameters> resourceConfiguration)
-        : base(resourceConfiguration)
-    {
-    }
-
-    /// <summary>Clones a container configuration (Testcontainers' builder contract).</summary>
-    public MemexConfiguration(IContainerConfiguration resourceConfiguration)
-        : base(resourceConfiguration)
-    {
-    }
-
-    /// <summary>Clones a memex configuration (Testcontainers' builder contract).</summary>
-    public MemexConfiguration(MemexConfiguration resourceConfiguration)
-        : this(new MemexConfiguration(), resourceConfiguration)
-    {
-    }
-
-    /// <summary>Merges two configurations, the newer winning (Testcontainers' builder contract).</summary>
-    public MemexConfiguration(MemexConfiguration oldValue, MemexConfiguration newValue)
-        : base(oldValue, newValue)
-    {
-        MemexConnectionString = BuildConfiguration.Combine(oldValue.MemexConnectionString, newValue.MemexConnectionString);
-    }
-
-    /// <summary>The Postgres the instance stores its data in, as reachable FROM the container.</summary>
-    public string? MemexConnectionString { get; }
-}
-
-/// <summary>
-/// Builds a <see cref="MemexContainer"/>. The image is the consumer's to name — the pinned portal
-/// image of the build under test (<c>meshweaver.azurecr.io/memex-portal-ai@sha256:…</c>); this
-/// module never guesses a tag. A Postgres connection string is required.
-/// </summary>
-public sealed class MemexBuilder : ContainerBuilder<MemexBuilder, MemexContainer, MemexConfiguration>
-{
-    /// <summary>The port the portal listens on inside the container.</summary>
-    public const ushort HttpPort = 8080;
-
-    /// <summary>
-    /// The startup census the wait strategy reads. NOT <c>/healthz</c>: that path answers a flat
-    /// <c>ok</c> on the setup wizard and on the GUI host's pre-mesh short-circuit alike, so it
-    /// proves a process, never a mesh (MeshWeaver#6037).
-    /// </summary>
-    public const string HealthPath = MemexReadiness.HealthPath;
-
-    /// <summary>The storage type <see cref="WithPostgres(string)"/> states.</summary>
-    public const string PostgresStorageType = "PostgreSql";
-
-    /// <summary>The writable data root inside the container (the image runs as a non-root user).</summary>
-    public const string DataRoot = "/tmp/memex-data";
-
-    /// <summary>Starts a builder with the memex defaults applied.</summary>
-    public MemexBuilder() : this(new MemexConfiguration())
-    {
-        DockerResourceConfiguration = Init().DockerResourceConfiguration;
-    }
-
-    private MemexBuilder(MemexConfiguration resourceConfiguration) : base(resourceConfiguration)
-    {
-        DockerResourceConfiguration = resourceConfiguration;
-    }
-
-    /// <inheritdoc />
-    protected override MemexConfiguration DockerResourceConfiguration { get; }
-
-    /// <summary>
-    /// The Postgres the memex stores its data in — <c>ConnectionStrings:memex</c> AND
-    /// <c>Graph:Storage:Type=PostgreSql</c>. The string must resolve FROM INSIDE the container: on a
-    /// shared Docker network, use the Postgres container's network alias and port 5432, not the
-    /// host-mapped port a test on the host would use.
-    ///
-    /// <para>🚨 The storage TYPE is not optional. The image deliberately bakes none (a baked type
-    /// would make the first-run wizard unreachable on every real deployment), and
-    /// <c>SetupOnlyHost.IsAwaitingSetup</c> reads the raw key: with only the connection string the
-    /// container serves the setup wizard and composes no mesh — which this helper did until
-    /// MeshWeaver#6037, while its <c>/healthz</c> wait reported it started.</para>
-    /// </summary>
-    public MemexBuilder WithPostgres(string connectionString)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(connectionString);
-        return Merge(DockerResourceConfiguration, new MemexConfiguration(memexConnectionString: connectionString))
-            .WithEnvironment("ConnectionStrings__memex", connectionString)
-            .WithEnvironment("Graph__Storage__Type", PostgresStorageType);
-    }
-
-    /// <summary>
-    /// Dev login on or off. On by default for a test instance; the host forces it OFF unless the
-    /// configured value is literally <c>true</c>, so this always writes an explicit value.
-    /// </summary>
-    public MemexBuilder WithDevLogin(bool enabled = true) =>
-        WithEnvironment("Authentication__EnableDevLogin", enabled ? "true" : "false");
-
-    /// <inheritdoc />
-    public override MemexContainer Build()
-    {
-        Validate();
-        return new MemexContainer(DockerResourceConfiguration);
-    }
-
-    /// <inheritdoc />
-    protected override MemexBuilder Init() =>
-        base.Init()
-            .WithPortBinding(HttpPort, assignRandomHostPort: true)
-            .WithEnvironment("ASPNETCORE_HTTP_PORTS", HttpPort.ToString(System.Globalization.CultureInfo.InvariantCulture))
-            // Azure-free, single-node: the self-host filesystem backend and Localhost clustering
-            // are the two switches that make the Distributed host run alone in one container.
-            .WithEnvironment("Deployment__Backend", "Filesystem")
-            .WithEnvironment("Deployment__DataRoot", DataRoot)
-            .WithEnvironment("Features__Orleans__Clustering", "Localhost")
-            .WithEnvironment("Authentication__EnableDevLogin", "true")
-            // The container's log IS the test's log.
-            .WithOutputConsumer(Consume.RedirectStdoutAndStderrToConsole())
-            // Started = the MESH started (MemexReadiness), never a probe path's flat 200: the setup
-            // wizard answers every probe path with "ok" and composes nothing (MeshWeaver#6037).
-            .WithWaitStrategy(Wait.ForUnixContainer().AddCustomWaitStrategy(new UntilMeshStarted()));
-
-    /// <inheritdoc />
-    protected override void Validate()
-    {
-        base.Validate();
-        if (string.IsNullOrWhiteSpace(DockerResourceConfiguration.MemexConnectionString))
-            throw new ArgumentException(
-                "a memex needs a Postgres: call WithPostgres(<connection string reachable from inside "
-                + "the container>) — the portal image runs Memex.Portal.Distributed, whose data lives "
-                + "in ConnectionStrings:memex, and an instance without it does not start.",
-                nameof(MemexConfiguration.MemexConnectionString));
-    }
-
-    /// <inheritdoc />
-    protected override MemexBuilder Clone(IResourceConfiguration<CreateContainerParameters> resourceConfiguration) =>
-        Merge(DockerResourceConfiguration, new MemexConfiguration(resourceConfiguration));
-
-    /// <inheritdoc />
-    protected override MemexBuilder Clone(IContainerConfiguration resourceConfiguration) =>
-        Merge(DockerResourceConfiguration, new MemexConfiguration(resourceConfiguration));
-
-    /// <inheritdoc />
-    protected override MemexBuilder Merge(MemexConfiguration oldValue, MemexConfiguration newValue) =>
-        new(new MemexConfiguration(oldValue, newValue));
-}
diff --git a/src/MeshWeaver.Testcontainers/MemexReadiness.cs b/src/MeshWeaver.Testcontainers/MemexReadiness.cs
deleted file mode 100644
index 0492829a48..0000000000
--- a/src/MeshWeaver.Testcontainers/MemexReadiness.cs
+++ /dev/null
@@ -1,183 +0,0 @@
-using DotNet.Testcontainers.Configurations;
-using DotNet.Testcontainers.Containers;
-
-namespace MeshWeaver.Testcontainers;
-
-/// <summary>
-/// What a memex container's HTTP surface says about whether its MESH has started — not merely its
-/// process (MeshWeaver#6037).
-///
-/// <para>🚨 <b>A probe path answering 200 proves nothing about the mesh.</b> Two hosts answer every
-/// probe path with a flat <c>200 ok</c> and neither has composed a mesh: the first-run setup
-/// wizard (<c>SetupOnlyHost</c> maps <c>/healthz</c>, <c>/health</c>, <c>/alive</c> and
-/// <c>/ready</c> to <c>ok</c> and redirects every other path to <c>/setup</c>), and the GUI host's
-/// <c>/healthz</c> short-circuit, which answers before identity, the mesh and the renderer by
-/// design. This helper used to wait on <c>/healthz</c>, and because its builder never stated
-/// <c>Graph:Storage:Type</c> the image ALWAYS booted the wizard — so every green start proved a
-/// started container and nothing more.</para>
-///
-/// <para>The verdict is therefore read off two things only a composed host produces:
-/// <list type="bullet">
-/// <item><b>The wizard, named and refused.</b> A non-probe path (<see cref="MeshPath"/>) answering a
-/// redirect to <c>/setup</c> is the setup-only host. That host never becomes a mesh without a person
-/// submitting the form, so it is a definitive <see cref="MemexReadinessState.SetupWizard"/> — the
-/// wait throws at once instead of polling to its timeout.</item>
-/// <item><b>The startup census.</b> A composed host serves <c>/health</c> through the
-/// health-check report writer, whose first line is the aggregate status word (<c>Healthy</c> or
-/// <c>Degraded</c>; <c>Unhealthy</c> answers 503) over every registered check — the database, the
-/// schema, the mesh. The wizard's <c>ok</c> is not a status word, so it can never satisfy this.</item>
-/// </list></para>
-/// </summary>
-public static class MemexReadiness
-{
-    /// <summary>The startup census the verdict reads — the chart's <c>startupProbe</c> path.</summary>
-    public const string HealthPath = "/health";
-
-    /// <summary>
-    /// A path no probe owns, answered by a composed host's own endpoint and redirected to
-    /// <c>/setup</c> by the wizard — the discriminator between the two hosts.
-    /// </summary>
-    public const string MeshPath = "/api/version";
-
-    /// <summary>The wizard's surface; a redirect here names the setup-only host.</summary>
-    public const string SetupPath = "/setup";
-
-    /// <summary>
-    /// The verdict from the two responses. Pure, so the decision is pinned without Docker.
-    /// </summary>
-    /// <param name="meshPathStatus">The status <see cref="MeshPath"/> answered, redirects NOT followed.</param>
-    /// <param name="meshPathLocation">That response's <c>Location</c>, if any.</param>
-    /// <param name="healthStatus">The status <see cref="HealthPath"/> answered.</param>
-    /// <param name="healthBody">That response's body.</param>
-    /// <returns>The state, with the reason a reader needs when it is not <see cref="MemexReadinessState.MeshStarted"/>.</returns>
-    public static MemexReadinessVerdict Classify(
-        int meshPathStatus, string? meshPathLocation, int healthStatus, string? healthBody)
-    {
-        if (meshPathStatus is >= 300 and < 400 && IsSetupLocation(meshPathLocation))
-            return new(MemexReadinessState.SetupWizard,
-                $"{MeshPath} redirected to {meshPathLocation}: the container is serving the FIRST-RUN "
-                + "SETUP wizard and composed no mesh. It will not become a mesh without a person "
-                + "submitting the form — the instance has no Graph:Storage:Type (MemexBuilder."
-                + "WithPostgres states it; a WithEnvironment that clears it lands here).");
-
-        var firstLine = (healthBody ?? "").Split('\n', 2)[0].Trim();
-        if (healthStatus == 200 && firstLine is "Healthy" or "Degraded")
-            return new(MemexReadinessState.MeshStarted,
-                $"{HealthPath} answered 200 with the startup census '{firstLine}'");
-
-        return new(MemexReadinessState.NotYet,
-            $"{HealthPath} answered {healthStatus} '{Clip(firstLine)}' — not the startup census of a "
-            + "composed mesh (Healthy/Degraded) yet");
-    }
-
-    /// <summary>
-    /// Probes a running memex over HTTP and classifies it. Redirects are never followed: the
-    /// redirect to <c>/setup</c> IS the evidence that names the wizard.
-    /// </summary>
-    /// <param name="baseAddress">The instance's HTTP root as seen from the caller.</param>
-    /// <param name="ct">Cancels the probe.</param>
-    /// <returns>The verdict; a refused connection is <see cref="MemexReadinessState.NotYet"/>.</returns>
-    internal static async Task<MemexReadinessVerdict> ProbeAsync(Uri baseAddress, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(baseAddress);
-        using var handler = new HttpClientHandler { AllowAutoRedirect = false };
-        using var http = new HttpClient(handler) { BaseAddress = baseAddress, Timeout = TimeSpan.FromSeconds(30) };
-        return await ProbeAsync(http, ct).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Probes through a caller's client — which must NOT follow redirects, or the wizard's redirect
-    /// to <c>/setup</c> is consumed before it can be read.
-    /// </summary>
-    /// <param name="http">A client whose <c>BaseAddress</c> is the instance's HTTP root.</param>
-    /// <param name="ct">Cancels the probe.</param>
-    /// <returns>The verdict; a refused connection is <see cref="MemexReadinessState.NotYet"/>.</returns>
-    internal static async Task<MemexReadinessVerdict> ProbeAsync(HttpClient http, CancellationToken ct = default)
-    {
-        ArgumentNullException.ThrowIfNull(http);
-        try
-        {
-            using var mesh = await http.GetAsync(MeshPath, ct).ConfigureAwait(false);
-            using var health = await http.GetAsync(HealthPath, ct).ConfigureAwait(false);
-            var body = await health.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
-            return Classify((int)mesh.StatusCode, mesh.Headers.Location?.ToString(), (int)health.StatusCode, body);
-        }
-        catch (HttpRequestException ex)
-        {
-            // The listener is not up yet. Keep waiting — the Testcontainers start budget bounds it.
-            return new(MemexReadinessState.NotYet, $"no HTTP answer yet: {ex.Message}");
-        }
-        catch (TaskCanceledException ex) when (!ct.IsCancellationRequested)
-        {
-            // The client's own per-request timeout: a booting host that accepted the socket but has
-            // not answered its census yet. The caller's cancellation is NOT swallowed (the filter).
-            return new(MemexReadinessState.NotYet, $"no HTTP answer within the request timeout: {ex.Message}");
-        }
-    }
-
-    private static bool IsSetupLocation(string? location)
-    {
-        if (string.IsNullOrEmpty(location)) return false;
-        var path = Uri.TryCreate(location, UriKind.Absolute, out var absolute) ? absolute.AbsolutePath : location.Split('?', 2)[0];
-        return path.Equals(SetupPath, StringComparison.OrdinalIgnoreCase)
-            || path.StartsWith(SetupPath + "/", StringComparison.OrdinalIgnoreCase);
-    }
-
-    private static string Clip(string s) => s.Length <= 80 ? s : s[..80] + "…";
-}
-
-/// <summary>What a memex's HTTP surface says about its mesh.</summary>
-public enum MemexReadinessState
-{
-    /// <summary>No startup census of a composed mesh yet — keep waiting.</summary>
-    NotYet,
-
-    /// <summary>The composed host answered its startup census Healthy or Degraded.</summary>
-    MeshStarted,
-
-    /// <summary>The setup-only host: no mesh, and none will come without a person. Terminal.</summary>
-    SetupWizard,
-}
-
-/// <summary>A readiness verdict and the reading behind it.</summary>
-/// <param name="State">The state.</param>
-/// <param name="Reason">What was read, for the test's output or the exception.</param>
-public sealed record MemexReadinessVerdict(MemexReadinessState State, string Reason);
-
-/// <summary>
-/// The wait strategy <see cref="MemexBuilder"/> installs: satisfied only by a started mesh, and
-/// FAILING at once — never polling to the timeout — when the container is the setup wizard.
-///
-/// <para>🚨 <b>Why throwing here ends the wait</b> (Testcontainers 4.15): <c>DockerContainer
-/// .CheckReadinessAsync</c> catches only <c>DockerApiException</c> around this predicate, and
-/// <c>WaitStrategy.WaitUntilAsync</c> rethrows a faulted predicate rather than retrying it, so
-/// <see cref="Decide"/>'s exception leaves <c>StartAsync</c> on the first poll that reads the
-/// wizard. <c>MemexReadinessTest</c> drives exactly that loop. A container that EXITS before its
-/// mesh starts (<c>DbVersionGate</c> over an unmigrated schema) needs nothing from this class: the
-/// same <c>CheckReadinessAsync</c> throws <c>ContainerNotRunningException</c> from its
-/// <c>finally</c> for the default <c>Running</c> mode.</para>
-///
-/// <para>The <see cref="Task"/> shape is the <see cref="IWaitUntil"/> contract, not a choice: this
-/// is Testcontainers' callback, in a test-support library with no hub and no mesh, and it is the
-/// ONLY task-shaped seam the library exposes — the probe behind it is internal.</para>
-/// </summary>
-internal sealed class UntilMeshStarted : IWaitUntil
-{
-    public async Task<bool> UntilAsync(IContainer container)
-    {
-        var baseAddress = new UriBuilder(Uri.UriSchemeHttp, container.Hostname,
-            container.GetMappedPublicPort(MemexBuilder.HttpPort)).Uri;
-        return Decide(await MemexReadiness.ProbeAsync(baseAddress).ConfigureAwait(false));
-    }
-
-    /// <summary>
-    /// The predicate's answer for one verdict: true when the mesh started, false to poll again,
-    /// and an exception — which ends the wait — for the setup wizard.
-    /// </summary>
-    internal static bool Decide(MemexReadinessVerdict verdict) => verdict.State switch
-    {
-        MemexReadinessState.MeshStarted => true,
-        MemexReadinessState.SetupWizard => throw new InvalidOperationException(verdict.Reason),
-        _ => false,
-    };
-}
diff --git a/src/MeshWeaver.Testcontainers/MeshWeaver.Testcontainers.csproj b/src/MeshWeaver.Testcontainers/MeshWeaver.Testcontainers.csproj
deleted file mode 100644
index bf41e975d2..0000000000
--- a/src/MeshWeaver.Testcontainers/MeshWeaver.Testcontainers.csproj
+++ /dev/null
@@ -1,21 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <!-- The memex test container: a real memex from the platform build as a test SUBSTRATE, the way
-         Testcontainers.PostgreSql gives a test a real Postgres (maintainer, 2026-08-30: "let's create
-         clean test container package for memex … similar to pg"). Test support, never a NuGet package:
-         consumers get it through the test container image or a source reference. -->
-    <IsPackable>false</IsPackable>
-    <Description>A Testcontainers module that starts the memex portal image as a disposable test substrate.</Description>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Testcontainers" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <!-- MemexReadinessTest drives the internal probe and the installed wait predicate against the
-         REAL setup-only host and MapDefaultEndpoints pipeline (#6037). Internal because the probe is
-         Task-shaped and the library's only Task seam should be Testcontainers' own IWaitUntil. -->
-    <InternalsVisibleTo Include="Memex.Portal.Shared.Test" />
-  </ItemGroup>
-</Project>
diff --git a/src/MeshWeaver.Testcontainers/README.md b/src/MeshWeaver.Testcontainers/README.md
deleted file mode 100644
index 165ce075e4..0000000000
--- a/src/MeshWeaver.Testcontainers/README.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# MeshWeaver.Testcontainers — a disposable memex as a test substrate
-
-A [Testcontainers](https://dotnet.testcontainers.org/) module that starts the **portal image the
-platform build produced** the way `Testcontainers.PostgreSql` starts a real Postgres: the test is a
-client of a real memex, and the platform under test is exactly the image the pipeline promoted — no
-core source checkout, no in-process mesh, no `MeshWeaver.Fixture`.
-
-```csharp
-await using INetwork network = new NetworkBuilder().Build();
-await using var postgres = new PostgreSqlBuilder("pgvector/pgvector:pg17")
-    .WithNetwork(network).WithNetworkAliases("postgres")
-    .WithDatabase("memex").WithUsername("postgres").WithPassword("postgres")
-    .Build();
-await postgres.StartAsync(ct);
-// …then run the memex-migration image of the SAME build once on `network` with
-// ConnectionStrings__memex set, and require exit code 0 — the portal refuses an unmigrated schema.
-
-await using var memex = new MemexBuilder()
-    .WithImage("meshweaver.azurecr.io/memex-portal-ai@sha256:…")   // the pinned build under test
-    .WithNetwork(network)
-    .WithPostgres("Host=postgres;Port=5432;Database=memex;Username=postgres;Password=postgres")
-    .Build();
-await memex.StartAsync(ct);
-
-// memex.BaseAddress, memex.McpEndpoint, memex.HealthEndpoint
-```
-
-## What the builder sets, and why
-
-The portal image runs `Memex.Portal.Distributed` (Orleans + Postgres). A throwaway instance is:
-
-| setting | value | reason |
-|---|---|---|
-| `Deployment:Backend` | `Filesystem` | Azure-free self-host backend; `Deployment:DataRoot=/tmp/memex-data` (the image runs non-root and cannot create `/data`) |
-| `Features:Orleans:Clustering` | `Localhost` | single silo in one container |
-| `ConnectionStrings:memex` | **required** — `WithPostgres(...)` | the instance's data; reachable *from inside* the container (a network alias, not a host-mapped port). Migrate it first with the `memex-migration` image of the same build — `DbVersionGate` refuses an unmigrated schema |
-| `Graph:Storage:Type` | `PostgreSql` — set by `WithPostgres(...)` | the image bakes no storage type, so without it the container serves the first-run SETUP wizard and composes no mesh (#6037) |
-| `Authentication:EnableDevLogin` | `true` (explicit) | the host forces it OFF unless the value is literally `true` |
-| wait strategy | `MemexReadiness`: `/health` answers the startup census (`Healthy`/`Degraded`) and `/api/version` is not redirected to `/setup` | the MESH started, not merely the process — a probe path's flat `200 ok` is answered by the setup wizard too. A wizard, or a container that exits first, fails `StartAsync` at once with the reason |
-| output | stdout/stderr → the test output | the container's log is the test's log |
-
-`WithImage` is the consumer's: this module never guesses a tag.
-
-## Where it fits
-
-- **Black-box and substrate suites** (the Postgres hosting suites, end-to-end flows) use this — a
-  memex on a Postgres, exercised over HTTP/MCP.
-- **Engine suites that inject fakes through DI** keep an in-process mesh; that is a different
-  primitive, not this one.
-- The library is test support: `IsPackable=false`, never a NuGet package.
diff --git a/test/Directory.Packages.props b/test/Directory.Packages.props
index 33f92c5fc5..fd35fdaef0 100644
--- a/test/Directory.Packages.props
+++ b/test/Directory.Packages.props
@@ -3,6 +3,5 @@
   <ItemGroup>
     <!-- Test-specific packages not in root Directory.Packages.props -->
     <PackageVersion Include="Microsoft.AspNetCore.TestHost" Version="10.0.12" />
-    <PackageVersion Include="Testcontainers.PostgreSql" Version="4.14.0" />
   </ItemGroup>
 </Project>
\ No newline at end of file